Merge 92639 - Scroll animator changes to nail the framerate

Source/WebCore/platform/ScrollAnimatorNone.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 30 matching lines @@
 #include "ScrollbarTheme.h"
 #include "TraceEvent.h"
 #include <algorithm>
 #include <wtf/CurrentTime.h>
 #include <wtf/PassOwnPtr.h>
 
 using namespace std;
 
 namespace WebCore {
 
-static double kTickTime = .0166;
-
-// This is used to set the timer delay - it needs to be slightly smaller than the tick count to leave some overhead.
-static double kAnimationTimerDelay = 0.015;
+static double kFrameRate = 60;
+static double kTickTime = 1 / kFrameRate;
+static double kMinimumTimerInterval = .001;
 
 PassOwnPtr<ScrollAnimator> ScrollAnimator::create(ScrollableArea* scrollableArea)
 {
     if (scrollableArea && scrollableArea->scrollAnimatorEnabled())
         return adoptPtr(new ScrollAnimatorNone(scrollableArea));
     return adoptPtr(new ScrollAnimator(scrollableArea));
 }
 
 ScrollAnimatorNone::Parameters::Parameters()
     : m_isEnabled(false)
@@ skipping 59 matching lines @@
         return t * t * 3;
     case Cubic:
         return t * t * t * 4;
     case Bounce:
         return t;
     }
 }
 
 ScrollAnimatorNone::PerAxisData::PerAxisData(ScrollAnimatorNone* parent, float* currentPosition)
     : m_currentPosition(currentPosition)
-    , m_animationTimer(parent, &ScrollAnimatorNone::animationTimerFired)
 {
     reset();
 }
 
 void ScrollAnimatorNone::PerAxisData::reset()
 {
     m_currentVelocity = 0;
 
     m_desiredPosition = 0;
     m_desiredVelocity = 0;
@@ skipping 42 matching lines @@
 
     if (newPosition == m_desiredPosition)
         return false;
 
     m_desiredPosition = newPosition;
 
     if (!m_startTime) {
         // FIXME: This should be the time from the event that got us here.
         m_startTime = currentTime - kTickTime / 2;
         m_startPosition = *m_currentPosition;
-        m_lastAnimationTime = currentTime;
+        m_lastAnimationTime = m_startTime;
     }
     m_startVelocity = m_currentVelocity;
 
     double remainingDelta = m_desiredPosition - *m_currentPosition;
 
     double attackAreaLeft = 0;
 
     double deltaTime = m_lastAnimationTime - m_startTime;
     double attackTimeLeft = max(0., m_attackTime - deltaTime);
     double timeLeft = m_animationTime - deltaTime;
@@ skipping 25 matching lines @@
         double roundOff = m_releasePosition - ((attackAreaLeft ? m_attackPosition : *m_currentPosition) + m_desiredVelocity * sustainTimeLeft);
         m_desiredVelocity += roundOff / sustainTimeLeft;
     }
 
     return true;
 }
 
 // FIXME: Add in jank detection trace events into this function.
 bool ScrollAnimatorNone::PerAxisData::animateScroll(double currentTime)
 {
-    // Get the current time; grabbing the current time once helps keep a consistent heartbeat.
     double lastScrollInterval = currentTime - m_lastAnimationTime;
+    if (lastScrollInterval < kMinimumTimerInterval)
+        return true;
+
     m_lastAnimationTime = currentTime;
 
     double deltaTime = currentTime - m_startTime;
     double newPosition = *m_currentPosition;
 
     if (deltaTime > m_animationTime) {
         *m_currentPosition = m_desiredPosition;
         reset();
         return false;
     }
@@ skipping 12 matching lines @@
         m_currentVelocity = (newPosition - *m_currentPosition) / lastScrollInterval;
     *m_currentPosition = newPosition;
 
     return true;
 }
 
 ScrollAnimatorNone::ScrollAnimatorNone(ScrollableArea* scrollableArea)
     : ScrollAnimator(scrollableArea)
     , m_horizontalData(this, &m_currentPosX)
     , m_verticalData(this, &m_currentPosY)
+    , m_animationTimer(this, &ScrollAnimatorNone::animationTimerFired)
 {
 }
 
 ScrollAnimatorNone::~ScrollAnimatorNone()
 {
-    stopAnimationTimerIfNeeded(&m_horizontalData);
-    stopAnimationTimerIfNeeded(&m_verticalData);
+    stopAnimationTimerIfNeeded();
 }
 
 bool ScrollAnimatorNone::scroll(ScrollbarOrientation orientation, ScrollGranularity granularity, float step, float multiplier)
 {
     if (!m_scrollableArea->scrollAnimatorEnabled())
         return ScrollAnimator::scroll(orientation, granularity, step, multiplier);
 
     // FIXME: get the type passed in. MouseWheel could also be by line, but should still have different
     // animation parameters than the keyboard.
     Parameters parameters;
@@ skipping 10 matching lines @@
         parameters = Parameters(true, 11 * kTickTime, 2 * kTickTime, Quadratic, 3 * kTickTime, Quadratic, 3 * kTickTime);
         break;
     default:
         break;
     }
 
     // If the individual input setting is disabled, bail.
     if (!parameters.m_isEnabled)
         return ScrollAnimator::scroll(orientation, granularity, step, multiplier);
 
-    // This is an animatable scroll. Calculate the scroll delta.
-    PerAxisData* data = (orientation == VerticalScrollbar) ? &m_verticalData : &m_horizontalData;
+    // This is an animatable scroll. Set the animation in motion using the appropriate parameters.
+    float scrollableSize = static_cast<float>(m_scrollableArea->scrollSize(orientation));
 
-    float scrollableSize = static_cast<float>(m_scrollableArea->scrollSize(orientation));
-    bool result = data->updateDataFromParameters(orientation, step, multiplier, scrollableSize, WTF::currentTime(), &parameters);
-    if (!data->m_animationTimer.isActive()) {
-        result &= data->animateScroll(WTF::currentTime());
-        if (result)
-            data->m_animationTimer.startOneShot(kAnimationTimerDelay);
+    PerAxisData& data = (orientation == VerticalScrollbar) ? m_verticalData : m_horizontalData;
+    bool needToScroll = data.updateDataFromParameters(orientation, step, multiplier, scrollableSize, WTF::monotonicallyIncreasingTime(), &parameters);
+    if (needToScroll && !m_animationTimer.isActive()) {
+        m_startTime = data.m_startTime;
+        animationTimerFired(&m_animationTimer);
     }
-    notityPositionChanged();
-    return result;
+    return needToScroll;
 }
 
 void ScrollAnimatorNone::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
 {
-    stopAnimationTimerIfNeeded(&m_horizontalData);
-    stopAnimationTimerIfNeeded(&m_verticalData);
+    stopAnimationTimerIfNeeded();
 
     m_horizontalData.reset();
     *m_horizontalData.m_currentPosition = offset.x();
     m_horizontalData.m_desiredPosition = offset.x();
 
     m_verticalData.reset();
     *m_verticalData.m_currentPosition = offset.y();
     m_verticalData.m_desiredPosition = offset.y();
 
     notityPositionChanged();
 }
 
 void ScrollAnimatorNone::animationTimerFired(Timer<ScrollAnimatorNone>* timer)
 {
-    double currentTime = WTF::currentTime();
-    if ((timer == &m_horizontalData.m_animationTimer) ?
-        m_horizontalData.animateScroll(currentTime) :
-        m_verticalData.animateScroll(currentTime))
-    {
-        double delta = WTF::currentTime() - currentTime;
-        timer->startOneShot(kAnimationTimerDelay - delta);
+    double currentTime = WTF::monotonicallyIncreasingTime();
+    double deltaToNextFrame = ceil((currentTime - m_startTime) * kFrameRate) / kFrameRate - (currentTime - m_startTime);
+
+    bool continueAnimation = false;
+    if (m_horizontalData.m_startTime && m_horizontalData.animateScroll(currentTime + deltaToNextFrame))
+        continueAnimation = true;
+    if (m_verticalData.m_startTime && m_verticalData.animateScroll(currentTime + deltaToNextFrame))
+        continueAnimation = true;
+    if (continueAnimation) {
+        double nextTimerInterval = max(kMinimumTimerInterval, deltaToNextFrame);
+        timer->startOneShot(nextTimerInterval);
     }
     notityPositionChanged();
 }
 
-void ScrollAnimatorNone::stopAnimationTimerIfNeeded(PerAxisData* data)
+void ScrollAnimatorNone::stopAnimationTimerIfNeeded()
 {
-    if (data->m_animationTimer.isActive())
-        data->m_animationTimer.stop();
+    if (m_animationTimer.isActive())
+        m_animationTimer.stop();
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(SMOOTH_SCROLLING)