Correctly update scroll offset animations in response to scroll anchoring

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 101 matching lines @@
         if (hasRunningAnimation())
             cancelAnimation();
         return ScrollAnimatorBase::userScroll(granularity, delta);
     }
 
     bool needsPostAnimationCleanup = m_runState == RunState::PostAnimationCleanup;
     if (m_runState == RunState::PostAnimationCleanup)
         resetAnimationState();
 
     FloatSize consumedDelta = computeDeltaToConsume(delta);
-
     FloatPoint targetPos = desiredTargetPosition();
     targetPos.move(consumedDelta);
 
     if (willAnimateToOffset(targetPos)) {
         m_lastGranularity = granularity;
         // Report unused delta only if there is no animation running. See
         // comment below regarding scroll latching.
         // TODO(bokan): Need to standardize how ScrollAnimators report
         // unusedDelta. This differs from ScrollAnimatorMac currently.
         return ScrollResult(true, true, 0, 0);
     }
 
     // If the run state when this method was called was PostAnimationCleanup and
     // we're not starting an animation, stay in PostAnimationCleanup state so
     // that the main thread scrolling reason can be removed.
     if (needsPostAnimationCleanup)
         m_runState = RunState::PostAnimationCleanup;
 
     // 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 ScrollResult(false, false, delta.width(), delta.height());
 }
 
 bool ScrollAnimator::willAnimateToOffset(const FloatPoint& targetPos)
 {
     if (m_runState == RunState::PostAnimationCleanup)
         resetAnimationState();
 
-    if (m_runState == RunState::WaitingToCancelOnCompositor) {
+    if (m_runState == RunState::WaitingToCancelOnCompositor
+        || m_runState == RunState::WaitingToCancelOnCompositorButNewScroll) {
         ASSERT(m_animationCurve);
         m_targetOffset = targetPos;
         if (registerAndScheduleAnimation())
             m_runState = RunState::WaitingToCancelOnCompositorButNewScroll;
         return true;
     }
 
     if (m_animationCurve) {
         if ((targetPos - m_targetOffset).isZero())
             return true;
@@ skipping 22 matching lines @@
 
     m_targetOffset = targetPos;
     m_startTime = m_timeFunction();
 
     if (registerAndScheduleAnimation())
         m_runState = RunState::WaitingToSendToCompositor;
 
     return true;
 }
 
+void ScrollAnimator::adjustAnimationAndSetScrollPosition(
+    IntSize adjustment, ScrollType scrollType)
+{
+    DoublePoint adjustedPos = m_scrollableArea->clampScrollPosition(
+        m_scrollableArea->scrollPositionDouble() + adjustment);
+    IntSize actualAdjustment = roundedIntPoint(adjustedPos) -
+        roundedIntPoint(m_scrollableArea->scrollPositionDouble());
+
+    m_scrollableArea->setScrollPosition(adjustedPos, scrollType);
+
+    if (m_runState == RunState::Idle) {
+        adjustImplOnlyScrollOffsetAnimation(actualAdjustment);
+    } else if (hasRunningAnimation()) {
+        m_targetOffset += toFloatSize(actualAdjustment);
+        if (m_animationCurve) {
+            m_animationCurve->applyAdjustment(actualAdjustment);
+            if (m_runState != RunState::RunningOnMainThread && registerAndScheduleAnimation())
+                m_runState = RunState::RunningOnCompositorButNeedsAdjustment;
+        }
+    }
+}
+
 void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
 {
     m_currentPos = offset;
 
     resetAnimationState();
     notifyPositionChanged();
 }
 
 void ScrollAnimator::tickAnimation(double monotonicTime)
 {
@@ skipping 61 matching lines @@
 }
 
 void ScrollAnimator::updateCompositorAnimations()
 {
     ScrollAnimatorCompositorCoordinator::updateCompositorAnimations();
     if (m_runState == RunState::PostAnimationCleanup) {
         postAnimationCleanupAndReset();
         return;
     }
 
-    if (m_compositorAnimationId && m_runState != RunState::RunningOnCompositor
-        && m_runState != RunState::RunningOnCompositorButNeedsUpdate
-        && m_runState != RunState::WaitingToCancelOnCompositorButNewScroll) {
-        // If the current run state is WaitingToSendToCompositor but we have a
-        // non-zero compositor animation id, there's a currently running
-        // compositor animation that needs to be removed here before the new
-        // animation is added below.
-        ASSERT(m_runState == RunState::WaitingToCancelOnCompositor
-            || m_runState == RunState::WaitingToSendToCompositor
-            || m_runState == RunState::RunningOnCompositorButNeedsTakeover);
+    if (m_runState == RunState::WaitingToCancelOnCompositor) {
+        DCHECK(m_compositorAnimationId);
+        abortAnimation();
+        postAnimationCleanupAndReset();
+        return;
+    }
 
-        if (m_runState == RunState::RunningOnCompositorButNeedsTakeover) {
-            // The animation is already aborted when the call to
-            // ::takeOverCompositorAnimation is made.
-            m_runState = RunState::WaitingToSendToCompositor;
-        } else {
-            abortAnimation();
-        }
-
-        m_compositorAnimationId = 0;
-        m_compositorAnimationGroupId = 0;
-        if (m_runState == RunState::WaitingToCancelOnCompositor) {
-            postAnimationCleanupAndReset();
-            return;
-        }
+    if (m_runState == RunState::RunningOnCompositorButNeedsTakeover) {
+        // The call to ::takeOverCompositorAnimation aborted the animation and
+        // put us in this state. The assumption is that takeOver is called
+        // because a main thread scrolling reason is added, and simply trying
+        // to ::sendAnimationToCompositor will fail and we will run on the main
+        // thread.
+        resetAnimationIds();
+        m_runState = RunState::WaitingToSendToCompositor;
     }
 
     if (m_runState == RunState::RunningOnCompositorButNeedsUpdate
-        || m_runState == RunState::WaitingToCancelOnCompositorButNewScroll) {
+        || m_runState == RunState::WaitingToCancelOnCompositorButNewScroll
+        || m_runState == RunState::RunningOnCompositorButNeedsAdjustment) {
         // Abort the running animation before a new one with an updated
         // target is added.
         abortAnimation();
+        resetAnimationIds();
 
-        m_compositorAnimationId = 0;
-        m_compositorAnimationGroupId = 0;
+        if (m_runState != RunState::RunningOnCompositorButNeedsAdjustment) {
+            // When in RunningOnCompositorButNeedsAdjustment, the call to
+            // ::adjustScrollOffsetAnimation should have made the necessary
+            // adjustment to the curve.
+            m_animationCurve->updateTarget(m_timeFunction() - m_startTime,
+                compositorOffsetFromBlinkOffset(m_targetOffset));
+        }
 
-        m_animationCurve->updateTarget(m_timeFunction() - m_startTime,
-            compositorOffsetFromBlinkOffset(m_targetOffset));
         if (m_runState == RunState::WaitingToCancelOnCompositorButNewScroll)
             m_animationCurve->setInitialValue(compositorOffsetFromBlinkOffset(currentPosition()));
+
         m_runState = RunState::WaitingToSendToCompositor;
     }
 
     if (m_runState == RunState::WaitingToSendToCompositor) {
         if (!m_compositorAnimationAttachedToLayerId)
             reattachCompositorPlayerIfNeeded(getScrollableArea()->compositorAnimationTimeline());
 
         if (!m_animationCurve) {
             m_animationCurve = adoptPtr(CompositorFactory::current().createScrollOffsetAnimationCurve(
                 compositorOffsetFromBlinkOffset(m_targetOffset),
@@ skipping 100 matching lines @@
     }
     return true;
 }
 
 DEFINE_TRACE(ScrollAnimator)
 {
     ScrollAnimatorBase::trace(visitor);
 }
 
 } // namespace blink