Share animations from compositor to main thread.

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

 /*
  * Copyright (c) 2011, 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 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * 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 "platform/scroll/ScrollAnimator.h"
 
+#include "cc/animation/scroll_offset_animation_curve.h"
 #include "platform/TraceEvent.h"
 #include "platform/animation/CompositorAnimation.h"
 #include "platform/graphics/CompositorFactory.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/scroll/MainThreadScrollingReason.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/PassRefPtr.h"
@@ skipping 70 matching lines @@
         return ScrollAnimatorBase::userScroll(orientation, granularity, step, delta);
     }
 
     float usedPixelDelta = computeDeltaToConsume(orientation, step * delta);
     FloatPoint pixelDelta = (orientation == VerticalScrollbar
         ? FloatPoint(0, usedPixelDelta) : FloatPoint(usedPixelDelta, 0));
 
     FloatPoint targetPos = desiredTargetPosition();
     targetPos.moveBy(pixelDelta);
 
+    if (willAnimateToOffset(targetPos)) {
+        m_lastGranularity = granularity;
+        // Report unused delta only if there is no animation running. See
+        // comment below regarding scroll latching.
+        return ScrollResultOneDimensional(/* didScroll */ true, /* unusedScrollDelta */ 0);
+    }
+    // Report unused delta only if there is no animation and we are not
+    // starting one. This ensures we latch for the duration of the
+    // animation rather than animating multiple scrollers at the same time.
+    return ScrollResultOneDimensional(/* didScroll */ false, delta);
+}
+
+bool ScrollAnimator::willAnimateToOffset(const FloatPoint& targetPos)
+{
     if (m_runState == RunState::PostAnimationCleanup)
         resetAnimationState();
 
     if (m_animationCurve && m_runState != RunState::WaitingToCancelOnCompositor) {
-        if ((targetPos - m_targetOffset).isZero()) {
-            // Report unused delta only if there is no animation running. See
-            // comment below regarding scroll latching.
-            return ScrollResultOneDimensional(/* didScroll */ true, /* unusedScrollDelta */ 0);
-        }
+        if ((targetPos - m_targetOffset).isZero())
+            return true;
 
         m_targetOffset = targetPos;
         ASSERT(m_runState == RunState::RunningOnMainThread
             || m_runState == RunState::RunningOnCompositor
             || m_runState == RunState::RunningOnCompositorButNeedsUpdate);
 
         if (m_runState == RunState::RunningOnCompositor
             || m_runState == RunState::RunningOnCompositorButNeedsUpdate) {
             if (registerAndScheduleAnimation())
                 m_runState = RunState::RunningOnCompositorButNeedsUpdate;
-            return ScrollResultOneDimensional(/* didScroll */ true, /* unusedScrollDelta */ 0);
+            return true;
         }
 
         // Running on the main thread, simply update the target offset instead
         // of sending to the compositor.
         m_animationCurve->updateTarget(m_timeFunction() - m_startTime, targetPos);
-        return ScrollResultOneDimensional(/* didScroll */ true, /* unusedScrollDelta */ 0);
+        return true;
     }
 
-    if ((targetPos - currentPosition()).isZero()) {
-        // Report unused delta only if there is no animation and we are not
-        // starting one. This ensures we latch for the duration of the
-        // animation rather than animating multiple scrollers at the same time.
-        return ScrollResultOneDimensional(/* didScroll */ false, delta);
-    }
+    if ((targetPos - currentPosition()).isZero())
+        return false;
 
     m_targetOffset = targetPos;
     m_startTime = m_timeFunction();
-    m_lastGranularity = granularity;
 
     if (registerAndScheduleAnimation())
         m_runState = RunState::WaitingToSendToCompositor;
 
-    return ScrollResultOneDimensional(/* didScroll */ true, /* unusedScrollDelta */ 0);
+    return true;
 }
 
 void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
 {
     m_currentPosX = offset.x();
     m_currentPosY = offset.y();
 
     resetAnimationState();
     notifyPositionChanged();
 }
@@ skipping 145 matching lines @@
     // An animation aborted by the compositor is treated as a finished
     // animation.
     ScrollAnimatorCompositorCoordinator::compositorAnimationFinished(groupId);
 }
 
 void ScrollAnimator::notifyCompositorAnimationFinished(int groupId)
 {
     ScrollAnimatorCompositorCoordinator::compositorAnimationFinished(groupId);
 }
 
+void ScrollAnimator::notifyAnimationTakeover(
+    double monotonicTime,
+    double animationStartTime,
+    scoped_ptr<cc::AnimationCurve> curve)
+{
+    // If there is already an animation running and the compositor asks to take
+    // over an animation, do nothing to avoid judder.
+    if (hasRunningAnimation())
+        return;
+
+    cc::ScrollOffsetAnimationCurve* scrollOffsetAnimationCurve =
+        curve->ToScrollOffsetAnimationCurve();
+    FloatPoint targetValue(scrollOffsetAnimationCurve->target_value().x(),
+        scrollOffsetAnimationCurve->target_value().y());
+    if (willAnimateToOffset(targetValue)) {
+        m_animationCurve = adoptPtr(
+            CompositorFactory::current().createScrollOffsetAnimationCurve(
+                std::move(scrollOffsetAnimationCurve)));
+        m_startTime = animationStartTime;
+    }
+}
+
 void ScrollAnimator::cancelAnimation()
 {
     ScrollAnimatorCompositorCoordinator::cancelAnimation();
 }
 
 void ScrollAnimator::layerForCompositedScrollingDidChange(
     CompositorAnimationTimeline* timeline)
 {
     if (reattachCompositorPlayerIfNeeded(timeline) && m_animationCurve)
         addMainThreadScrollingReason();
 }
 
 bool ScrollAnimator::registerAndScheduleAnimation()
 {
     scrollableArea()->registerForAnimation();
     if (!m_scrollableArea->scheduleAnimation()) {
         scrollToOffsetWithoutAnimation(m_targetOffset);
         resetAnimationState();
         return false;
     }
     return true;
 }
 
 DEFINE_TRACE(ScrollAnimator)
 {
     ScrollAnimatorBase::trace(visitor);
 }
 
 } // namespace blink