[webkit-changes] [92002] trunk/Source

Fri, 29 Jul 2011 12:12:01 -0700

Title: [92002] trunk/Source
Revision
92002
Author
[email protected]
Date
2011-07-29 12:11:49 -0700 (Fri, 29 Jul 2011)

Log Message

Scroll animation refinements.
https://bugs.webkit.org/show_bug.cgi?id=65154

Patch by Scott Byer <[email protected]> on 2011-07-29
Reviewed by Adam Barth.

Fix scroll animation bugs when scrolling to the ends of a document. Smooth over slow event repeat rates
better. Fix tests to allow for unit testing of scrolling up and not just down.

Source/WebCore:

Additional unit tests added to ScrollAnimatorNoneTest:
ScrollQuadraticSmoothed, ScrollLotsQuadraticSmoothed, ScrollDownToBumper, ScrollUpToBumper

* platform/ScrollAnimatorNone.cpp:
(WebCore::ScrollAnimatorNone::Parameters::Parameters):
(WebCore::ScrollAnimatorNone::PerAxisData::updateDataFromParameters):
(WebCore::ScrollAnimatorNone::scroll):
* platform/ScrollAnimatorNone.h:

Source/WebKit/chromium:

Additional unit tests added to ScrollAnimatorNoneTest:
ScrollQuadraticSmoothed, ScrollLotsQuadraticSmoothed, ScrollDownToBumper, ScrollUpToBumper

* tests/ScrollAnimatorNoneTest.cpp:
(ScrollAnimatorNoneTest::reset):
(ScrollAnimatorNoneTest::updateDataFromParameters):
(ScrollAnimatorNoneTest::animateScroll):
(ScrollAnimatorNoneTest::checkDesiredPosition):
(ScrollAnimatorNoneTest::checkSoftLanding):

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (92001 => 92002)


--- trunk/Source/WebCore/ChangeLog	2011-07-29 17:47:53 UTC (rev 92001)
+++ trunk/Source/WebCore/ChangeLog	2011-07-29 19:11:49 UTC (rev 92002)
@@ -1,3 +1,22 @@
+2011-07-29  Scott Byer  <[email protected]>
+
+        Scroll animation refinements.
+        https://bugs.webkit.org/show_bug.cgi?id=65154
+
+        Reviewed by Adam Barth.
+
+        Fix scroll animation bugs when scrolling to the ends of a document. Smooth over slow event repeat rates
+        better. Fix tests to allow for unit testing of scrolling up and not just down.
+
+        Additional unit tests added to ScrollAnimatorNoneTest:
+        ScrollQuadraticSmoothed, ScrollLotsQuadraticSmoothed, ScrollDownToBumper, ScrollUpToBumper
+
+        * platform/ScrollAnimatorNone.cpp:
+        (WebCore::ScrollAnimatorNone::Parameters::Parameters):
+        (WebCore::ScrollAnimatorNone::PerAxisData::updateDataFromParameters):
+        (WebCore::ScrollAnimatorNone::scroll):
+        * platform/ScrollAnimatorNone.h:
+
 2011-07-29  Samuel White  <[email protected]>
 
         Add the ability to search the AccessibilityObject cache

Modified: trunk/Source/WebCore/platform/ScrollAnimatorNone.cpp (92001 => 92002)


--- trunk/Source/WebCore/platform/ScrollAnimatorNone.cpp	2011-07-29 17:47:53 UTC (rev 92001)
+++ trunk/Source/WebCore/platform/ScrollAnimatorNone.cpp	2011-07-29 19:11:49 UTC (rev 92002)
@@ -44,6 +44,8 @@
 #include <wtf/CurrentTime.h>
 #include <wtf/PassOwnPtr.h>
 
+using namespace std;
+
 namespace WebCore {
 
 static double kTickTime = .0166;
@@ -63,9 +65,10 @@
 {
 }
 
-ScrollAnimatorNone::Parameters::Parameters(bool isEnabled, double animationTime, Curve attackCurve, double attackTime, Curve releaseCurve, double releaseTime)
+ScrollAnimatorNone::Parameters::Parameters(bool isEnabled, double animationTime, double repeatMinimumSustainTime, Curve attackCurve, double attackTime, Curve releaseCurve, double releaseTime)
     : m_isEnabled(isEnabled)
     , m_animationTime(animationTime)
+    , m_repeatMinimumSustainTime(repeatMinimumSustainTime)
     , m_attackCurve(attackCurve)
     , m_attackTime(attackTime)
     , m_releaseCurve(releaseCurve)
@@ -159,7 +162,8 @@
 
 bool ScrollAnimatorNone::PerAxisData::updateDataFromParameters(ScrollbarOrientation orientation, float step, float multiplier, float scrollableSize, double currentTime, Parameters* parameters)
 {
-    m_animationTime = parameters->m_animationTime;
+    if (parameters->m_animationTime > m_animationTime)
+        m_animationTime = parameters->m_animationTime;
     m_attackTime = parameters->m_attackTime;
     m_releaseTime = parameters->m_releaseTime;
     m_attackCurve = parameters->m_attackCurve;
@@ -174,12 +178,12 @@
 
     m_orientation = orientation;
 
-    if (!m_desiredPosition)
+    if (!m_startTime)
         m_desiredPosition = *m_currentPosition;
     float newPosition = m_desiredPosition + (step * multiplier);
 
     if (newPosition < 0 || newPosition > scrollableSize)
-        newPosition = std::max(std::min(newPosition, scrollableSize), 0.0f);
+        newPosition = max(min(newPosition, scrollableSize), 0.0f);
 
     if (newPosition == m_desiredPosition)
         return false;
@@ -199,15 +203,17 @@
     double attackAreaLeft = 0;
 
     double deltaTime = m_lastAnimationTime - m_startTime;
+    double attackTimeLeft = max(0., m_attackTime - deltaTime);
     double timeLeft = m_animationTime - deltaTime;
-    if (timeLeft < m_releaseTime) {
-        m_animationTime = deltaTime + m_releaseTime;
-        timeLeft = m_releaseTime;
+    double minTimeLeft = m_releaseTime + min(parameters->m_repeatMinimumSustainTime, m_animationTime - m_releaseTime - attackTimeLeft);
+    if (timeLeft < minTimeLeft) {
+        m_animationTime = deltaTime + minTimeLeft;
+        timeLeft = minTimeLeft;
     }
-    double releaseTimeLeft = std::min(timeLeft, m_releaseTime);
-    double attackTimeLeft = std::max(0., m_attackTime - deltaTime);
-    double sustainTimeLeft = std::max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
 
+    double releaseTimeLeft = min(timeLeft, m_releaseTime);
+    double sustainTimeLeft = max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
+
     if (attackTimeLeft) {
         double attackSpot = deltaTime / m_attackTime;
         attackAreaLeft = attackTimeLeft / (curveDerivativeAt(m_attackCurve, 1) - curveDerivativeAt(m_attackCurve, attackSpot));
@@ -289,13 +295,13 @@
     case ScrollByDocument:
         break;
     case ScrollByLine:
-        parameters = Parameters(true, 10 * kTickTime, Quadratic, 3 * kTickTime, Quadratic, 3 * kTickTime);
+        parameters = Parameters(true, 10 * kTickTime, 7 * kTickTime, Quadratic, 3 * kTickTime, Quadratic, 3 * kTickTime);
         break;
     case ScrollByPage:
-        parameters = Parameters(true, 15 * kTickTime, Quadratic, 5 * kTickTime, Quadratic, 5 * kTickTime);
+        parameters = Parameters(true, 15 * kTickTime, 10 * kTickTime, Quadratic, 5 * kTickTime, Quadratic, 5 * kTickTime);
         break;
     case ScrollByPixel:
-        parameters = Parameters(true, 11 * kTickTime, Quadratic, 3 * kTickTime, Quadratic, 3 * kTickTime);
+        parameters = Parameters(true, 11 * kTickTime, 2 * kTickTime, Quadratic, 3 * kTickTime, Quadratic, 3 * kTickTime);
         break;
     default:
         break;

Modified: trunk/Source/WebCore/platform/ScrollAnimatorNone.h (92001 => 92002)


--- trunk/Source/WebCore/platform/ScrollAnimatorNone.h	2011-07-29 17:47:53 UTC (rev 92001)
+++ trunk/Source/WebCore/platform/ScrollAnimatorNone.h	2011-07-29 19:11:49 UTC (rev 92002)
@@ -59,13 +59,14 @@
 
     struct Parameters {
         Parameters();
-        Parameters(bool, double, Curve, double, Curve, double);
+        Parameters(bool isEnabled, double animationTime, double repeatMinimumSustainTime, Curve attackCurve, double attackTime, Curve releaseCurve, double releaseTime);
 
         // Note that the times can be overspecified such that releaseTime or releaseTime and attackTime are greater
         // than animationTime. animationTime takes priority over releaseTime, capping it. attackTime is capped at
         // whatever time remains, or zero if none.
         bool m_isEnabled;
         double m_animationTime;
+        double m_repeatMinimumSustainTime;
 
         Curve m_attackCurve;
         double m_attackTime;

Modified: trunk/Source/WebKit/chromium/ChangeLog (92001 => 92002)


--- trunk/Source/WebKit/chromium/ChangeLog	2011-07-29 17:47:53 UTC (rev 92001)
+++ trunk/Source/WebKit/chromium/ChangeLog	2011-07-29 19:11:49 UTC (rev 92002)
@@ -1,3 +1,23 @@
+2011-07-29  Scott Byer  <[email protected]>
+
+        Scroll animation refinements.
+        https://bugs.webkit.org/show_bug.cgi?id=65154
+
+        Reviewed by Adam Barth.
+
+        Fix scroll animation bugs when scrolling to the ends of a document. Smooth over slow event repeat rates
+        better. Fix tests to allow for unit testing of scrolling up and not just down.
+
+        Additional unit tests added to ScrollAnimatorNoneTest:
+        ScrollQuadraticSmoothed, ScrollLotsQuadraticSmoothed, ScrollDownToBumper, ScrollUpToBumper
+        
+        * tests/ScrollAnimatorNoneTest.cpp:
+        (ScrollAnimatorNoneTest::reset):
+        (ScrollAnimatorNoneTest::updateDataFromParameters):
+        (ScrollAnimatorNoneTest::animateScroll):
+        (ScrollAnimatorNoneTest::checkDesiredPosition):
+        (ScrollAnimatorNoneTest::checkSoftLanding):
+
 2011-07-28  Naoki Takano  <[email protected]>
 
         [Chromium] Add form() function to access parent WebFormElement from WebFormControlElement.

Modified: trunk/Source/WebKit/chromium/tests/ScrollAnimatorNoneTest.cpp (92001 => 92002)


--- trunk/Source/WebKit/chromium/tests/ScrollAnimatorNoneTest.cpp	2011-07-29 17:47:53 UTC (rev 92001)
+++ trunk/Source/WebKit/chromium/tests/ScrollAnimatorNoneTest.cpp	2011-07-29 19:11:49 UTC (rev 92002)
@@ -176,12 +176,16 @@
     void curveTestInner(ScrollAnimatorNone::Curve, double step, double time);
     void curveTest(ScrollAnimatorNone::Curve);
 
+    void checkDesiredPosition(float expectedPosition);
+    void checkSoftLanding(float expectedPosition);
+
     static double kTickTime;
     static double kAnimationTime;
     static double kStartTime;
     static double kEndTime;
     float m_currentPosition;
     MockScrollAnimatorNone m_mockScrollAnimatorNone;
+    bool m_scrollingDown;
     ScrollAnimatorNone::PerAxisData* m_data;
 };
 
@@ -193,15 +197,21 @@
 void ScrollAnimatorNoneTest::reset()
 {
     m_data->reset();
+    m_scrollingDown = true;
 }
 
 bool ScrollAnimatorNoneTest::updateDataFromParameters(ScrollbarOrientation orientation, float step, float multiplier, float scrollableSize, double currentTime, ScrollAnimatorNone::Parameters* parameters)
 {
+    m_scrollingDown = (step * multiplier > 0);
+
     double oldVelocity = m_data->m_currentVelocity;
     double oldDesiredVelocity = m_data->m_desiredVelocity;
     double oldTimeLeft = m_data->m_animationTime - (m_data->m_lastAnimationTime - m_data->m_startTime);
     bool result = m_data->updateDataFromParameters(orientation, step, multiplier, scrollableSize, currentTime, parameters);
-    EXPECT_LE(oldVelocity, m_data->m_currentVelocity);
+    if (m_scrollingDown)
+        EXPECT_LE(oldVelocity, m_data->m_currentVelocity);
+    else
+        EXPECT_GE(oldVelocity, m_data->m_currentVelocity);
 
     double deltaTime = m_data->m_lastAnimationTime - m_data->m_startTime;
     double timeLeft = m_data->m_animationTime - deltaTime;
@@ -212,10 +222,17 @@
     // If we're getting near the finish, the desired velocity can decrease since the time left gets increased.
     double allowedVelocityDecreaseFactor = 0.99 * oldTimeLeft / timeLeft;
     allowedVelocityDecreaseFactor *= allowedVelocityDecreaseFactor;
-    EXPECT_LE(oldDesiredVelocity * allowedVelocityDecreaseFactor, m_data->m_desiredVelocity);
+    if (m_scrollingDown)
+        EXPECT_LE(oldDesiredVelocity * allowedVelocityDecreaseFactor, m_data->m_desiredVelocity);
+    else
+        EXPECT_GE(oldDesiredVelocity * allowedVelocityDecreaseFactor, m_data->m_desiredVelocity);
 
-    double expectedReleasePosition = std::max<double>(m_currentPosition, m_data->m_attackPosition) + sustainTimeLeft * m_data->m_desiredVelocity;
-    EXPECT_DOUBLE_EQ(expectedReleasePosition, m_data->m_releasePosition);
+    double startPosition = m_scrollingDown ? std::max<double>(m_currentPosition, m_data->m_attackPosition) : std::min<double>(m_currentPosition, m_data->m_attackPosition);
+    double expectedReleasePosition = startPosition + sustainTimeLeft * m_data->m_desiredVelocity;
+    if (result)
+        EXPECT_DOUBLE_EQ(expectedReleasePosition, m_data->m_releasePosition);
+    else
+        EXPECT_NEAR(expectedReleasePosition, m_data->m_releasePosition, 1);
 
     return result;
 }
@@ -234,11 +251,16 @@
     double sustainTimeLeft = std::max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
     double distanceLeft = m_data->m_desiredPosition - *m_data->m_currentPosition;
 
-    EXPECT_LE(0, m_data->m_currentVelocity);
-    EXPECT_LE(oldPosition, *m_data->m_currentPosition);
-    EXPECT_GE(m_data->m_desiredVelocity * 2, m_data->m_currentVelocity);
+    if (m_scrollingDown) {
+        EXPECT_LE(0, m_data->m_currentVelocity);
+        EXPECT_LE(oldPosition, *m_data->m_currentPosition);
+    } else {
+        EXPECT_GE(0, m_data->m_currentVelocity);
+        EXPECT_GE(oldPosition, *m_data->m_currentPosition);
+    }
+    EXPECT_GE(fabs(m_data->m_desiredVelocity) * 2, fabs(m_data->m_currentVelocity));
     if (testEstimatedMaxVelocity)
-        EXPECT_GE((distanceLeft / sustainTimeLeft) * 1.2, m_data->m_currentVelocity);
+        EXPECT_GE(fabs(distanceLeft / sustainTimeLeft) * 1.2, fabs(m_data->m_currentVelocity));
 
     return result;
 }
@@ -363,6 +385,17 @@
     curveTestInner(curve, 0.25, 40);
 }
 
+void ScrollAnimatorNoneTest::checkDesiredPosition(float expectedPosition)
+{
+    EXPECT_EQ(expectedPosition, m_data->m_desiredPosition);
+}
+
+void ScrollAnimatorNoneTest::checkSoftLanding(float expectedPosition)
+{
+    EXPECT_EQ(expectedPosition, m_currentPosition);
+    EXPECT_LE(m_data->m_desiredVelocity / 2, m_data->m_currentVelocity);
+}
+
 TEST_F(ScrollAnimatorNoneTest, CurveMathLinear)
 {
     curveTest(ScrollAnimatorNone::Linear);
@@ -385,7 +418,7 @@
 
 TEST_F(ScrollAnimatorNoneTest, ScrollOnceLinear)
 {
-    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, ScrollAnimatorNone::Linear, 3 * kTickTime, ScrollAnimatorNone::Linear, 3 * kTickTime);
+    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Linear, 3 * kTickTime, ScrollAnimatorNone::Linear, 3 * kTickTime);
 
     updateDataFromParameters(VerticalScrollbar, 1, 40, 1000, kStartTime, &parameters);
     bool result = true;
@@ -395,7 +428,7 @@
 
 TEST_F(ScrollAnimatorNoneTest, ScrollOnceQuadratic)
 {
-    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
+    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
 
     updateDataFromParameters(VerticalScrollbar, 1, 40, 1000, kStartTime, &parameters);
     bool result = true;
@@ -405,7 +438,7 @@
 
 TEST_F(ScrollAnimatorNoneTest, ScrollLongQuadratic)
 {
-    ScrollAnimatorNone::Parameters parameters(true, 20 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
+    ScrollAnimatorNone::Parameters parameters(true, 20 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
 
     updateDataFromParameters(VerticalScrollbar, 1, 40, 1000, kStartTime, &parameters);
     bool result = true;
@@ -415,7 +448,7 @@
 
 TEST_F(ScrollAnimatorNoneTest, ScrollQuadraticNoSustain)
 {
-    ScrollAnimatorNone::Parameters parameters(true, 8 * kTickTime, ScrollAnimatorNone::Quadratic, 4 * kTickTime, ScrollAnimatorNone::Quadratic, 4 * kTickTime);
+    ScrollAnimatorNone::Parameters parameters(true, 8 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 4 * kTickTime, ScrollAnimatorNone::Quadratic, 4 * kTickTime);
 
     updateDataFromParameters(VerticalScrollbar, 1, 40, 1000, kStartTime, &parameters);
     bool result = true;
@@ -423,9 +456,19 @@
         result = animateScroll(t);
 }
 
+TEST_F(ScrollAnimatorNoneTest, ScrollQuadraticSmoothed)
+{
+    ScrollAnimatorNone::Parameters parameters(true, 8 * kTickTime, 8 * kTickTime, ScrollAnimatorNone::Quadratic, 4 * kTickTime, ScrollAnimatorNone::Quadratic, 4 * kTickTime);
+
+    updateDataFromParameters(VerticalScrollbar, 1, 40, 1000, kStartTime, &parameters);
+    bool result = true;
+    for (double t = kStartTime; result && t < kEndTime; t += kAnimationTime)
+        result = animateScroll(t);
+}
+
 TEST_F(ScrollAnimatorNoneTest, ScrollOnceCubic)
 {
-    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime);
+    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime);
 
     updateDataFromParameters(VerticalScrollbar, 1, 40, 1000, kStartTime, &parameters);
     bool result = true;
@@ -435,7 +478,7 @@
 
 TEST_F(ScrollAnimatorNoneTest, ScrollOnceShort)
 {
-    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime);
+    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime);
 
     updateDataFromParameters(VerticalScrollbar, 1, 40, 1000, kStartTime, &parameters);
     bool result = true;
@@ -445,7 +488,7 @@
 
 TEST_F(ScrollAnimatorNoneTest, ScrollTwiceQuadratic)
 {
-    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
+    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
 
     updateDataFromParameters(VerticalScrollbar, 1, 40, 1000, kStartTime, &parameters);
     bool result = true;
@@ -476,7 +519,7 @@
 
 TEST_F(ScrollAnimatorNoneTest, ScrollLotsQuadratic)
 {
-    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
+    ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
 
     updateDataFromParameters(VerticalScrollbar, 1, 40, 1000, kStartTime, &parameters);
     bool result = true;
@@ -495,9 +538,30 @@
         result = result && animateScroll(t);
 }
 
+TEST_F(ScrollAnimatorNoneTest, ScrollLotsQuadraticSmoothed)
+{
+    ScrollAnimatorNone::Parameters parameters(true, 10 * kTickTime, 6 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
+
+    updateDataFromParameters(VerticalScrollbar, 1, 40, 1000, kStartTime, &parameters);
+    bool result = true;
+    double t;
+    for (t = kStartTime; result && t < kStartTime + 1.5 * kTickTime; t += kAnimationTime)
+        result = animateScroll(t);
+
+    for (int i = 0; i < 20; ++i) {
+        t += kAnimationTime;
+        result = result && animateScroll(t);
+        result = result && updateDataFromParameters(VerticalScrollbar, 3, 40, 10000, t, &parameters);
+    }
+
+    t += kAnimationTime;
+    for (; result && t < kEndTime; t += kAnimationTime)
+        result = result && animateScroll(t);
+}
+
 TEST_F(ScrollAnimatorNoneTest, ScrollWheelTrace)
 {
-    ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
+    ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
 
     // Constructed from an actual scroll wheel trace that exhibited a glitch.
     bool result = updateDataFromParameters(VerticalScrollbar, 1, 53.33, 1000, 100.5781, &parameters);
@@ -519,9 +583,33 @@
         result = result && animateScroll(t);
 }
 
+TEST_F(ScrollAnimatorNoneTest, ScrollWheelTraceSmoothed)
+{
+    ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, 7 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
+
+    // Constructed from an actual scroll wheel trace that exhibited a glitch.
+    bool result = updateDataFromParameters(VerticalScrollbar, 1, 53.33, 1000, 100.5781, &parameters);
+    result = animateScroll(100.5933);
+    result = result && animateScroll(100.6085);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1, 53.33, 1000, 100.6485, &parameters);
+    result = result && animateScroll(100.6515);
+    result = result && animateScroll(100.6853);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1, 53.33, 1000, 100.6863, &parameters);
+    result = result && animateScroll(100.7005);
+    result = result && animateScroll(100.7157);
+    result = result && animateScroll(100.7312);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1, 53.33, 1000, 100.7379, &parameters);
+    result = result && animateScroll(100.7464);
+    result = result && animateScroll(100.7617);
+    result = result && animateScroll(100.7775);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1, 53.33, 1000, 100.7779, &parameters);
+    for (double t = 100.7928; result && t < 200; t += 0.015)
+        result = result && animateScroll(t);
+}
+
 TEST_F(ScrollAnimatorNoneTest, LinuxTrackPadTrace)
 {
-    ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
+    ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
 
     bool result = updateDataFromParameters(VerticalScrollbar, 1.00, 60.00, 1000, 100.6863, &parameters);
     result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 20.00, 1000, 100.6897, &parameters);
@@ -549,4 +637,75 @@
         result = result && animateScroll(t);
 }
 
+TEST_F(ScrollAnimatorNoneTest, LinuxTrackPadTraceSmoothed)
+{
+    ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, 7 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
+
+    bool result = updateDataFromParameters(VerticalScrollbar, 1.00, 60.00, 1000, 100.6863, &parameters);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 20.00, 1000, 100.6897, &parameters);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 20.00, 1000, 100.7001, &parameters);
+    result = result && animateScroll(100.7015);
+    result = result && animateScroll(100.7169);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 40.00, 1000, 100.7179, &parameters);
+    result = result && animateScroll(100.7322);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 20.00, 1000, 100.7332, &parameters);
+    result = result && animateScroll(100.7491);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 20.00, 1000, 100.7519, &parameters);
+    result = result && animateScroll(100.7676);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 20.00, 1000, 100.7698, &parameters);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 20.00, 1000, 100.7830, &parameters);
+    result = result && animateScroll(100.7834);
+    result = result && animateScroll(100.7997);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 20.00, 1000, 100.8019, &parameters);
+    result = result && animateScroll(100.8154);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 20.00, 1000, 100.8241, &parameters);
+    result = result && animateScroll(100.8335);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 20.00, 1000, 100.8465, &parameters);
+    result = result && animateScroll(100.8513);
+    result = result && updateDataFromParameters(VerticalScrollbar, 1.00, 20.00, 1000, 100.8623, &parameters);
+    for (double t = 100.8674; result && t < 200; t += 0.015)
+        result = result && animateScroll(t);
+}
+
+TEST_F(ScrollAnimatorNoneTest, ScrollDownToBumper)
+{
+    ScrollAnimatorNone::Parameters parameters(true, 10 * kTickTime, 7 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
+
+    updateDataFromParameters(VerticalScrollbar, 1, 20, 200, kStartTime, &parameters);
+    bool result = true;
+    double t = kStartTime;
+    for (int i = 0; i < 10; ++i) {
+        t += kAnimationTime;
+        result = result && animateScroll(t);
+        updateDataFromParameters(VerticalScrollbar, 1, 20, 200, t, &parameters);
+    }
+    checkDesiredPosition(200);
+
+    t += kAnimationTime;
+    for (; result && t < kEndTime; t += kAnimationTime)
+        result = result && animateScroll(t);
+    checkSoftLanding(200);
+}
+
+
+TEST_F(ScrollAnimatorNoneTest, ScrollUpToBumper)
+{
+    ScrollAnimatorNone::Parameters parameters(true, 10 * kTickTime, 7 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime);
+
+    updateDataFromParameters(VerticalScrollbar, 1, -20, 200, kStartTime, &parameters);
+    bool result = true;
+    double t = kStartTime;
+    for (int i = 0; i < 10; ++i) {
+        t += kAnimationTime;
+        result = result && animateScroll(t);
+        updateDataFromParameters(VerticalScrollbar, 1, -20, 200, t, &parameters);
+    }
+    checkDesiredPosition(0);
+
+    t += kAnimationTime;
+    for (; result && t < kEndTime; t += kAnimationTime)
+        result = result && animateScroll(t);
+    checkSoftLanding(0);
+}
+
 #endif // ENABLE(SMOOTH_SCROLLING)

_______________________________________________
webkit-changes mailing list
[email protected]
http://lists.webkit.org/mailman/listinfo.cgi/webkit-changes

Reply via email to