Don't skip a frame when running smooth scroll animation on 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 168 matching lines @@
             m_runState = RunState::RunningOnCompositorButNeedsUpdate;
         return true;
     }
 
     if ((targetPos - currentPosition()).isZero())
         return false;
 
     m_targetOffset = targetPos;
     m_startTime = m_timeFunction();
 
-    if (registerAndScheduleAnimation())
-        m_runState = RunState::WaitingToSendToCompositor;
+    if (registerAndScheduleAnimation()) {
+        if (m_scrollableArea->shouldScrollOnMainThread()) {
+            createAnimationCurve();
+            m_runState = RunState::RunningOnMainThread;
+        } else {
+            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) -
@@ skipping 79 matching lines @@
     bool sentToCompositor = addAnimation(std::move(animation));
     if (sentToCompositor) {
         m_runState = RunState::RunningOnCompositor;
         m_compositorAnimationId = animationId;
         m_compositorAnimationGroupId = animationGroupId;
     }
 
     return sentToCompositor;
 }
 
+void ScrollAnimator::createAnimationCurve()
+{
+    DCHECK(!m_animationCurve);
+    m_animationCurve = adoptPtr(CompositorFactory::current().createScrollOffsetAnimationCurve(
+        compositorOffsetFromBlinkOffset(m_targetOffset),
+        m_lastGranularity == ScrollByPixel ?
+            CompositorScrollOffsetAnimationCurve::ScrollDurationInverseDelta :
+            CompositorScrollOffsetAnimationCurve::ScrollDurationConstant));
+    m_animationCurve->setInitialValue(compositorOffsetFromBlinkOffset(currentPosition()));
+}
+
 void ScrollAnimator::updateCompositorAnimations()
 {
     ScrollAnimatorCompositorCoordinator::updateCompositorAnimations();
+    if (m_runState == RunState::RunningOnMainThread) {
+        // We add a temporary main thread scrolling reason so that subsequent
+        // scrolls get handled on the main thread. This is removed when the
+        // animation is finished in ::tickAnimation.
+        addMainThreadScrollingReason();
+        return;
+    }
+
     if (m_runState == RunState::PostAnimationCleanup) {
         postAnimationCleanupAndReset();
         return;
     }
 
     if (m_runState == RunState::WaitingToCancelOnCompositor) {
         DCHECK(m_compositorAnimationId);
         abortAnimation();
         postAnimationCleanupAndReset();
         return;
@@ skipping 28 matching lines @@
         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),
-                m_lastGranularity == ScrollByPixel ?
-                    CompositorScrollOffsetAnimationCurve::ScrollDurationInverseDelta :
-                    CompositorScrollOffsetAnimationCurve::ScrollDurationConstant));
-            m_animationCurve->setInitialValue(compositorOffsetFromBlinkOffset(currentPosition()));
-        }
+        if (!m_animationCurve)
+            createAnimationCurve();
 
         bool runningOnMainThread = false;
         bool sentToCompositor = sendAnimationToCompositor();
         if (!sentToCompositor) {
             runningOnMainThread = registerAndScheduleAnimation();
             if (runningOnMainThread)
                 m_runState = RunState::RunningOnMainThread;
         }
 
         // Main thread should deal with the scroll animations it started.
         if (sentToCompositor || runningOnMainThread)
             addMainThreadScrollingReason();
         else
             removeMainThreadScrollingReason();
     }
 }
 
 void ScrollAnimator::addMainThreadScrollingReason()
 {
     if (WebLayer* scrollLayer = toWebLayer(getScrollableArea()->layerForScrolling())) {
+        uint32_t reasons = scrollLayer->mainThreadScrollingReasons();
+        if (reasons & MainThreadScrollingReason::kAnimatingScrollOnMainThread)
+            return;

[ajuma, 2016/06/02 14:07:27]

cc::Layer::AddMainThreadScrollingReasons already earlies-out when adding an
existing reason, so do we need this additional early-out here?

[ymalik, 2016/06/02 14:13:10]

We essentially call this function every time we're in RunningOnMainThread from
updateCompositorAnimation. I added this so that we aren't relying on
cc::Layer::AddMainThreadScrollingReasons to do so. I don't have a strong opinion
either way. WDYT?

[ajuma, 2016/06/02 14:20:27]

The call to mainThreadScrollingReasons() winds up in
cc::Layer::main_thread_scrolling_reasons(), so I think in terms of efficiency it
basically amounts to the same thing. But I don't feel strongly about it either.

[ymalik, 2016/06/02 14:30:08]

Removed.

         scrollLayer->addMainThreadScrollingReasons(
             MainThreadScrollingReason::kAnimatingScrollOnMainThread);
     }
 }
 
 void ScrollAnimator::removeMainThreadScrollingReason()
 {
     if (WebLayer* scrollLayer = toWebLayer(getScrollableArea()->layerForScrolling())) {
         scrollLayer->clearMainThreadScrollingReasons(
             MainThreadScrollingReason::kAnimatingScrollOnMainThread);
@@ skipping 65 matching lines @@
     }
     return true;
 }
 
 DEFINE_TRACE(ScrollAnimator)
 {
     ScrollAnimatorBase::trace(visitor);
 }
 
 } // namespace blink