Fix retargeting of composited smooth scrolls from the 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 32 matching lines @@
 
 PassOwnPtrWillBeRawPtr<ScrollAnimatorBase> ScrollAnimatorBase::create(ScrollableArea* scrollableArea)
 {
     if (scrollableArea && scrollableArea->scrollAnimatorEnabled())
         return adoptPtrWillBeNoop(new ScrollAnimator(scrollableArea));
     return adoptPtrWillBeNoop(new ScrollAnimatorBase(scrollableArea));
 }
 
 ScrollAnimator::ScrollAnimator(ScrollableArea* scrollableArea, WTF::TimeFunction timeFunction)
     : ScrollAnimatorBase(scrollableArea)
-    , m_lastTickTime(0.0)
     , m_timeFunction(timeFunction)
 {
 }
 
 ScrollAnimator::~ScrollAnimator()
 {
 }
 
 FloatPoint ScrollAnimator::desiredTargetPosition() const
 {
@@ skipping 43 matching lines @@
             return ScrollResultOneDimensional(/* didScroll */ true, /* unusedScrollDelta */ 0);
         }
 
         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) {
-            m_runState = RunState::RunningOnCompositorButNeedsUpdate;
+            if (registerAndScheduleAnimation())
+                m_runState = RunState::RunningOnCompositorButNeedsUpdate;
             return ScrollResultOneDimensional(/* didScroll */ true, /* unusedScrollDelta */ 0);
         }
 
         // 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);
     }
 
     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);
     }
 
     m_targetOffset = targetPos;
     m_startTime = m_timeFunction();
 
-    scrollableArea()->registerForAnimation();
-    if (!m_scrollableArea->scheduleAnimation()) {
-        scrollToOffsetWithoutAnimation(targetPos);
-        resetAnimationState();
-        return ScrollResultOneDimensional(/* didScroll */ true, /* unusedScrollDelta */ 0);
-    }
+    if (registerAndScheduleAnimation())
+        m_runState = RunState::WaitingToSendToCompositor;
 
-    m_runState = RunState::WaitingToSendToCompositor;
     return ScrollResultOneDimensional(/* didScroll */ true, /* unusedScrollDelta */ 0);
 }
 
 void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
 {
     m_currentPosX = offset.x();
     m_currentPosY = offset.y();
 
     resetAnimationState();
     notifyPositionChanged();
 }
 
 void ScrollAnimator::tickAnimation(double monotonicTime)
 {
-    m_lastTickTime = monotonicTime;
-
     if (m_runState != RunState::RunningOnMainThread)
         return;
 
     TRACE_EVENT0("blink", "ScrollAnimator::tickAnimation");
     double elapsedTime = monotonicTime - m_startTime;
 
     bool isFinished = (elapsedTime > m_animationCurve->duration());
     FloatPoint offset = isFinished ? m_animationCurve->targetValue()
         : m_animationCurve->getValue(elapsedTime);
 
@@ skipping 35 matching lines @@
     if (m_runState == RunState::WaitingToSendToCompositor
         || m_runState == RunState::RunningOnCompositorButNeedsUpdate) {
         if (m_runState == RunState::RunningOnCompositorButNeedsUpdate) {
             // Abort the running animation before a new one with an updated
             // target is added.
             abortAnimation();
 
             m_compositorAnimationId = 0;
             m_compositorAnimationGroupId = 0;
 
-            m_animationCurve->updateTarget(m_lastTickTime - m_startTime,
+            m_animationCurve->updateTarget(m_timeFunction() - m_startTime,
                 m_targetOffset);
             m_runState = RunState::WaitingToSendToCompositor;
         }
 
         if (!m_animationCurve) {
             m_animationCurve = adoptPtr(Platform::current()->compositorSupport()
                 ->createScrollOffsetAnimationCurve(
                     m_targetOffset,
                     WebCompositorAnimationCurve::TimingFunctionTypeEaseInOut,
                     WebScrollOffsetAnimationCurve::ScrollDurationConstant));
@@ skipping 22 matching lines @@
                 sentToCompositor = addAnimation(animation.release());
                 if (sentToCompositor) {
                     m_runState = RunState::RunningOnCompositor;
                     m_compositorAnimationId = animationId;
                     m_compositorAnimationGroupId = animationGroupId;
                 }
             }
         }
 
         if (!sentToCompositor) {
-            m_runState = RunState::RunningOnMainThread;
-            if (!m_scrollableArea->scheduleAnimation()) {
-                scrollToOffsetWithoutAnimation(m_targetOffset);
-                resetAnimationState();
-            }
+            if (registerAndScheduleAnimation())
+                m_runState = RunState::RunningOnMainThread;
         }
     }
 }
 
 void ScrollAnimator::notifyCompositorAnimationFinished(int groupId)
 {
     ScrollAnimatorCompositorCoordinator::compositorAnimationFinished(groupId);
 }
 
 void ScrollAnimator::cancelAnimation()
 {
     ScrollAnimatorCompositorCoordinator::cancelAnimation();
 }
 
 void ScrollAnimator::layerForCompositedScrollingDidChange(
     WebCompositorAnimationTimeline* timeline)
 {
     reattachCompositorPlayerIfNeeded(timeline);
 }
 
+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