Title: [209087] trunk/Source/WebCore
Revision
209087
Author
[email protected]
Date
2016-11-29 13:12:26 -0800 (Tue, 29 Nov 2016)

Log Message

Address post-review feedback following r209070 (AppKit momentum scrolling adoption for scroll snapping)
https://bugs.webkit.org/show_bug.cgi?id=165147

Reviewed by Simon Fraser.

Addresses some additional review feedback after r209070, which adopts _NSScrollingMomentumCalculator for scroll
snapping. See individual changes below for more details. No new tests, since there is no behavior change.

* page/EventHandler.cpp:
(WebCore::handleWheelEventInAppropriateEnclosingBox):
(WebCore::EventHandler::defaultWheelEventHandler):
* page/Page.cpp:
(WebCore::Page::ensureTestTrigger):
* page/WheelEventDeltaFilter.cpp:
(WebCore::WheelEventDeltaFilter::filteredVelocity):
* page/WheelEventDeltaFilter.h:
* page/mac/WheelEventDeltaFilterMac.mm:
(WebCore::WheelEventDeltaFilterMac::updateFromDelta):
* page/scrolling/AsyncScrollingCoordinator.cpp:
(WebCore::AsyncScrollingCoordinator::updateExpectsWheelEventTestTriggerWithFrameView):
* page/scrolling/AsyncScrollingCoordinator.h:
* page/scrolling/ScrollingCoordinator.h:
(WebCore::ScrollingCoordinator::updateExpectsWheelEventTestTriggerWithFrameView):

Rather than force a complete layout pass when the Page first acquires a WheelEventTestTrigger, we now simply
have the scrolling coordinator update its frame node to expect a wheel event test trigger.

* page/scrolling/ScrollingMomentumCalculator.cpp:
(WebCore::ScrollingMomentumCalculator::ScrollingMomentumCalculator):
(WebCore::ScrollingMomentumCalculator::create):
(WebCore::BasicScrollingMomentumCalculator::BasicScrollingMomentumCalculator):
(WebCore::BasicScrollingMomentumCalculator::scrollOffsetAfterElapsedTime):
(WebCore::BasicScrollingMomentumCalculator::animationDuration):
(WebCore::BasicScrollingMomentumCalculator::initializeSnapProgressCurve):
(WebCore::BasicScrollingMomentumCalculator::animationProgressAfterElapsedTime):
* page/scrolling/ScrollingMomentumCalculator.h:
* page/scrolling/mac/ScrollingMomentumCalculatorMac.h:
* page/scrolling/mac/ScrollingMomentumCalculatorMac.mm:
(WebCore::ScrollingMomentumCalculator::create):
(WebCore::ScrollingMomentumCalculatorMac::ScrollingMomentumCalculatorMac):
(WebCore::ScrollingMomentumCalculatorMac::scrollOffsetAfterElapsedTime):
(WebCore::ScrollingMomentumCalculatorMac::animationDuration):
(WebCore::ScrollingMomentumCalculatorMac::ensurePlatformMomentumCalculator):
* platform/PlatformWheelEvent.h:
(WebCore::PlatformWheelEvent::copyWithDeltasAndVelocity):
(WebCore::PlatformWheelEvent::scrollingVelocity):

Change scrolling velocity in PlatformWheelEvent to be a FloatSize instead of a FloatPoint. This change
propagates to the ScrollController, where state variables and arguments pertaining to scrolling velocity are
also now sizes instead of points.

* platform/cocoa/ScrollController.h:
* platform/cocoa/ScrollController.mm:
(WebCore::ScrollController::scheduleStatelessScrollSnap):
* platform/cocoa/ScrollSnapAnimatorState.h:
* platform/cocoa/ScrollSnapAnimatorState.mm:
(WebCore::ScrollSnapAnimatorState::transitionToGlideAnimationState):
(WebCore::ScrollSnapAnimatorState::setupAnimationForState):
(WebCore::ScrollSnapAnimatorState::teardownAnimationForState):
(WebCore::ScrollSnapAnimatorState::currentAnimatedScrollOffset):

Refactor elapsed time to be Seconds instead of double. Additionally, use MonotonicTime::now() instead of
monotonicallyIncreasingTime(), and MonotonicTime instead of double for keeping track of the start time.

* platform/spi/mac/NSScrollingMomentumCalculatorSPI.h:

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (209086 => 209087)


--- trunk/Source/WebCore/ChangeLog	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/ChangeLog	2016-11-29 21:12:26 UTC (rev 209087)
@@ -1,3 +1,71 @@
+2016-11-29  Wenson Hsieh  <[email protected]>
+
+        Address post-review feedback following r209070 (AppKit momentum scrolling adoption for scroll snapping)
+        https://bugs.webkit.org/show_bug.cgi?id=165147
+
+        Reviewed by Simon Fraser.
+
+        Addresses some additional review feedback after r209070, which adopts _NSScrollingMomentumCalculator for scroll
+        snapping. See individual changes below for more details. No new tests, since there is no behavior change.
+
+        * page/EventHandler.cpp:
+        (WebCore::handleWheelEventInAppropriateEnclosingBox):
+        (WebCore::EventHandler::defaultWheelEventHandler):
+        * page/Page.cpp:
+        (WebCore::Page::ensureTestTrigger):
+        * page/WheelEventDeltaFilter.cpp:
+        (WebCore::WheelEventDeltaFilter::filteredVelocity):
+        * page/WheelEventDeltaFilter.h:
+        * page/mac/WheelEventDeltaFilterMac.mm:
+        (WebCore::WheelEventDeltaFilterMac::updateFromDelta):
+        * page/scrolling/AsyncScrollingCoordinator.cpp:
+        (WebCore::AsyncScrollingCoordinator::updateExpectsWheelEventTestTriggerWithFrameView):
+        * page/scrolling/AsyncScrollingCoordinator.h:
+        * page/scrolling/ScrollingCoordinator.h:
+        (WebCore::ScrollingCoordinator::updateExpectsWheelEventTestTriggerWithFrameView):
+
+        Rather than force a complete layout pass when the Page first acquires a WheelEventTestTrigger, we now simply
+        have the scrolling coordinator update its frame node to expect a wheel event test trigger.
+
+        * page/scrolling/ScrollingMomentumCalculator.cpp:
+        (WebCore::ScrollingMomentumCalculator::ScrollingMomentumCalculator):
+        (WebCore::ScrollingMomentumCalculator::create):
+        (WebCore::BasicScrollingMomentumCalculator::BasicScrollingMomentumCalculator):
+        (WebCore::BasicScrollingMomentumCalculator::scrollOffsetAfterElapsedTime):
+        (WebCore::BasicScrollingMomentumCalculator::animationDuration):
+        (WebCore::BasicScrollingMomentumCalculator::initializeSnapProgressCurve):
+        (WebCore::BasicScrollingMomentumCalculator::animationProgressAfterElapsedTime):
+        * page/scrolling/ScrollingMomentumCalculator.h:
+        * page/scrolling/mac/ScrollingMomentumCalculatorMac.h:
+        * page/scrolling/mac/ScrollingMomentumCalculatorMac.mm:
+        (WebCore::ScrollingMomentumCalculator::create):
+        (WebCore::ScrollingMomentumCalculatorMac::ScrollingMomentumCalculatorMac):
+        (WebCore::ScrollingMomentumCalculatorMac::scrollOffsetAfterElapsedTime):
+        (WebCore::ScrollingMomentumCalculatorMac::animationDuration):
+        (WebCore::ScrollingMomentumCalculatorMac::ensurePlatformMomentumCalculator):
+        * platform/PlatformWheelEvent.h:
+        (WebCore::PlatformWheelEvent::copyWithDeltasAndVelocity):
+        (WebCore::PlatformWheelEvent::scrollingVelocity):
+
+        Change scrolling velocity in PlatformWheelEvent to be a FloatSize instead of a FloatPoint. This change
+        propagates to the ScrollController, where state variables and arguments pertaining to scrolling velocity are
+        also now sizes instead of points.
+
+        * platform/cocoa/ScrollController.h:
+        * platform/cocoa/ScrollController.mm:
+        (WebCore::ScrollController::scheduleStatelessScrollSnap):
+        * platform/cocoa/ScrollSnapAnimatorState.h:
+        * platform/cocoa/ScrollSnapAnimatorState.mm:
+        (WebCore::ScrollSnapAnimatorState::transitionToGlideAnimationState):
+        (WebCore::ScrollSnapAnimatorState::setupAnimationForState):
+        (WebCore::ScrollSnapAnimatorState::teardownAnimationForState):
+        (WebCore::ScrollSnapAnimatorState::currentAnimatedScrollOffset):
+
+        Refactor elapsed time to be Seconds instead of double. Additionally, use MonotonicTime::now() instead of
+        monotonicallyIncreasingTime(), and MonotonicTime instead of double for keeping track of the start time.
+
+        * platform/spi/mac/NSScrollingMomentumCalculatorSPI.h:
+
 2016-11-29  Brady Eidson  <[email protected]>
 
         IndexedDB 2.0: The client's transaction operation queue should flush as much to the server as possible.

Modified: trunk/Source/WebCore/page/EventHandler.cpp (209086 => 209087)


--- trunk/Source/WebCore/page/EventHandler.cpp	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/EventHandler.cpp	2016-11-29 21:12:26 UTC (rev 209087)
@@ -303,7 +303,7 @@
     return didHandleWheelEvent;
 }
 
-static inline bool handleWheelEventInAppropriateEnclosingBox(Node* startNode, WheelEvent& wheelEvent, Element** stopElement, const FloatSize& filteredPlatformDelta, const FloatPoint& filteredVelocity)
+static inline bool handleWheelEventInAppropriateEnclosingBox(Node* startNode, WheelEvent& wheelEvent, Element** stopElement, const FloatSize& filteredPlatformDelta, const FloatSize& filteredVelocity)
 {
     bool shouldHandleEvent = wheelEvent.deltaX() || wheelEvent.deltaY();
 #if PLATFORM(MAC)
@@ -2758,7 +2758,7 @@
     Ref<Frame> protectedFrame(m_frame);
 
     FloatSize filteredPlatformDelta(wheelEvent.deltaX(), wheelEvent.deltaY());
-    FloatPoint filteredVelocity;
+    FloatSize filteredVelocity;
     if (const PlatformWheelEvent* platformWheelEvent = wheelEvent.wheelEvent()) {
         filteredPlatformDelta.setWidth(platformWheelEvent->deltaX());
         filteredPlatformDelta.setHeight(platformWheelEvent->deltaY());

Modified: trunk/Source/WebCore/page/Page.cpp (209086 => 209087)


--- trunk/Source/WebCore/page/Page.cpp	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/Page.cpp	2016-11-29 21:12:26 UTC (rev 209087)
@@ -1995,8 +1995,11 @@
 {
     if (!m_testTrigger) {
         m_testTrigger = adoptRef(new WheelEventTestTrigger());
-        if (auto* frameView = mainFrame().view())
-            frameView->layout();
+        // We need to update the scrolling coordinator so that the mainframe scrolling node can expect wheel event test triggers.
+        if (auto* frameView = mainFrame().view()) {
+            if (m_scrollingCoordinator)
+                m_scrollingCoordinator->updateExpectsWheelEventTestTriggerWithFrameView(*frameView);
+        }
     }
 
     return *m_testTrigger;

Modified: trunk/Source/WebCore/page/WheelEventDeltaFilter.cpp (209086 => 209087)


--- trunk/Source/WebCore/page/WheelEventDeltaFilter.cpp	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/WheelEventDeltaFilter.cpp	2016-11-29 21:12:26 UTC (rev 209087)
@@ -63,7 +63,7 @@
     return m_currentFilteredDelta;
 }
 
-FloatPoint WheelEventDeltaFilter::filteredVelocity() const
+FloatSize WheelEventDeltaFilter::filteredVelocity() const
 {
     return m_currentFilteredVelocity;
 }

Modified: trunk/Source/WebCore/page/WheelEventDeltaFilter.h (209086 => 209087)


--- trunk/Source/WebCore/page/WheelEventDeltaFilter.h	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/WheelEventDeltaFilter.h	2016-11-29 21:12:26 UTC (rev 209087)
@@ -25,7 +25,6 @@
 
 #pragma once
 
-#include "FloatPoint.h"
 #include "FloatSize.h"
 #include <wtf/Deque.h>
 
@@ -40,13 +39,13 @@
     WEBCORE_EXPORT virtual void updateFromDelta(const FloatSize&) = 0;
     WEBCORE_EXPORT virtual void beginFilteringDeltas() = 0;
     WEBCORE_EXPORT virtual void endFilteringDeltas() = 0;
-    WEBCORE_EXPORT FloatPoint filteredVelocity() const;
+    WEBCORE_EXPORT FloatSize filteredVelocity() const;
     WEBCORE_EXPORT bool isFilteringDeltas() const;
     WEBCORE_EXPORT FloatSize filteredDelta() const;
 
 protected:
     FloatSize m_currentFilteredDelta;
-    FloatPoint m_currentFilteredVelocity;
+    FloatSize m_currentFilteredVelocity;
     bool m_isFilteringDeltas { false };
 };
 

Modified: trunk/Source/WebCore/page/mac/WheelEventDeltaFilterMac.mm (209086 => 209087)


--- trunk/Source/WebCore/page/mac/WheelEventDeltaFilterMac.mm	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/mac/WheelEventDeltaFilterMac.mm	2016-11-29 21:12:26 UTC (rev 209087)
@@ -55,7 +55,7 @@
     NSPoint filteredDeltaResult;
     NSPoint filteredVelocityResult;
     [m_predominantAxisFilter filterInputDelta:NSPoint(FloatPoint(delta.width(), delta.height())) timestamp:monotonicallyIncreasingTime() - m_beginFilteringDeltasTime outputDelta:&filteredDeltaResult velocity:&filteredVelocityResult];
-    m_currentFilteredVelocity = FloatPoint(filteredVelocityResult);
+    m_currentFilteredVelocity = FloatSize(filteredVelocityResult.x, filteredVelocityResult.y);
     m_currentFilteredDelta = FloatSize(filteredDeltaResult.x, filteredDeltaResult.y);
 }
 

Modified: trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp (209086 => 209087)


--- trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp	2016-11-29 21:12:26 UTC (rev 209087)
@@ -172,6 +172,19 @@
     node->setScrollableAreaParameters(scrollParameters);
 }
 
+void AsyncScrollingCoordinator::updateExpectsWheelEventTestTriggerWithFrameView(const FrameView& frameView)
+{
+    auto* page = frameView.frame().page();
+    if (!page)
+        return;
+
+    auto* node = downcast<ScrollingStateFrameScrollingNode>(m_scrollingStateTree->stateNodeForID(frameView.scrollLayerID()));
+    if (!node)
+        return;
+
+    node->setExpectsWheelEventTestTrigger(page->expectsWheelEventTriggers());
+}
+
 void AsyncScrollingCoordinator::frameViewEventTrackingRegionsChanged(FrameView&)
 {
     if (!m_scrollingStateTree->rootStateNode())

Modified: trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h (209086 => 209087)


--- trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h	2016-11-29 21:12:26 UTC (rev 209087)
@@ -64,6 +64,8 @@
     WEBCORE_EXPORT void updateScrollSnapPropertiesWithFrameView(const FrameView&) override;
 #endif
 
+    WEBCORE_EXPORT void updateExpectsWheelEventTestTriggerWithFrameView(const FrameView&) override;
+
 protected:
     WEBCORE_EXPORT AsyncScrollingCoordinator(Page*);
 

Modified: trunk/Source/WebCore/page/scrolling/ScrollingCoordinator.h (209086 => 209087)


--- trunk/Source/WebCore/page/scrolling/ScrollingCoordinator.h	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/scrolling/ScrollingCoordinator.h	2016-11-29 21:12:26 UTC (rev 209087)
@@ -206,6 +206,7 @@
     String synchronousScrollingReasonsAsText() const;
 
     EventTrackingRegions absoluteEventTrackingRegions() const;
+    virtual void updateExpectsWheelEventTestTriggerWithFrameView(const FrameView&) { }
 
 protected:
     explicit ScrollingCoordinator(Page*);

Modified: trunk/Source/WebCore/page/scrolling/ScrollingMomentumCalculator.cpp (209086 => 209087)


--- trunk/Source/WebCore/page/scrolling/ScrollingMomentumCalculator.cpp	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/scrolling/ScrollingMomentumCalculator.cpp	2016-11-29 21:12:26 UTC (rev 209087)
@@ -28,13 +28,12 @@
 
 #include "FloatPoint.h"
 #include "FloatSize.h"
-#include <wtf/CurrentTime.h>
 
 namespace WebCore {
 
-static const double scrollSnapAnimationDuration = 1;
+static const Seconds scrollSnapAnimationDuration = 1_s;
 
-ScrollingMomentumCalculator::ScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity)
+ScrollingMomentumCalculator::ScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
     : m_initialDelta(initialDelta)
     , m_initialVelocity(initialVelocity)
     , m_initialScrollOffset(initialOffset.x(), initialOffset.y())
@@ -46,7 +45,7 @@
 
 #if !HAVE(NSSCROLLING_FILTERS)
 
-std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity)
+std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
 {
     return std::make_unique<BasicScrollingMomentumCalculator>(viewportSize, contentSize, initialOffset, targetOffset, initialDelta, initialVelocity);
 }
@@ -53,7 +52,7 @@
 
 #endif
 
-BasicScrollingMomentumCalculator::BasicScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity)
+BasicScrollingMomentumCalculator::BasicScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
     : ScrollingMomentumCalculator(viewportSize, contentSize, initialOffset, targetOffset, initialDelta, initialVelocity)
 {
 }
@@ -73,7 +72,7 @@
     return interpolatedPoint;
 }
 
-FloatPoint BasicScrollingMomentumCalculator::scrollOffsetAfterElapsedTime(double seconds)
+FloatPoint BasicScrollingMomentumCalculator::scrollOffsetAfterElapsedTime(Seconds elapsedTime)
 {
     if (m_momentumCalculatorRequiresInitialization) {
         initializeSnapProgressCurve();
@@ -81,12 +80,12 @@
         m_momentumCalculatorRequiresInitialization = false;
     }
 
-    float progress = animationProgressAfterElapsedTime(seconds);
+    float progress = animationProgressAfterElapsedTime(elapsedTime);
     auto offsetAsSize = m_forceLinearAnimationCurve ? linearlyInterpolatedOffsetAtProgress(progress) : cubicallyInterpolatedOffsetAtProgress(progress);
     return FloatPoint(offsetAsSize.width(), offsetAsSize.height());
 }
 
-double BasicScrollingMomentumCalculator::animationDuration()
+Seconds BasicScrollingMomentumCalculator::animationDuration()
 {
     return scrollSnapAnimationDuration;
 }
@@ -191,7 +190,7 @@
     m_snapAnimationCurveMagnitude = initialScrollSnapCurveMagnitude;
     for (int i = 0; i < maxNumScrollSnapParameterEstimationIterations; ++i) {
         m_snapAnimationDecayFactor = m_snapAnimationCurveMagnitude / (m_snapAnimationCurveMagnitude - initialProgress);
-        m_snapAnimationCurveMagnitude = 1.0f / (1.0f - std::pow(m_snapAnimationDecayFactor, -framesPerSecond * scrollSnapAnimationDuration));
+        m_snapAnimationCurveMagnitude = 1.0f / (1.0f - std::pow(m_snapAnimationDecayFactor, -framesPerSecond * scrollSnapAnimationDuration.value()));
         if (std::abs(m_snapAnimationDecayFactor - previousDecayFactor) < scrollSnapDecayFactorConvergenceThreshold)
             break;
 
@@ -199,10 +198,10 @@
     }
 }
 
-float BasicScrollingMomentumCalculator::animationProgressAfterElapsedTime(double seconds) const
+float BasicScrollingMomentumCalculator::animationProgressAfterElapsedTime(Seconds elapsedTime) const
 {
-    float timeProgress = clampTo<float>(seconds / scrollSnapAnimationDuration, 0, 1);
-    return std::min(1.0, m_snapAnimationCurveMagnitude * (1.0 - std::pow(m_snapAnimationDecayFactor, -framesPerSecond * scrollSnapAnimationDuration * timeProgress)));
+    float timeProgress = clampTo<float>(elapsedTime / scrollSnapAnimationDuration, 0, 1);
+    return std::min(1.0, m_snapAnimationCurveMagnitude * (1.0 - std::pow(m_snapAnimationDecayFactor, -framesPerSecond * scrollSnapAnimationDuration.value() * timeProgress)));
 }
 
 }; // namespace WebCore

Modified: trunk/Source/WebCore/page/scrolling/ScrollingMomentumCalculator.h (209086 => 209087)


--- trunk/Source/WebCore/page/scrolling/ScrollingMomentumCalculator.h	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/scrolling/ScrollingMomentumCalculator.h	2016-11-29 21:12:26 UTC (rev 209087)
@@ -30,6 +30,7 @@
 #include "AxisScrollSnapOffsets.h"
 #include "PlatformWheelEvent.h"
 #include "ScrollTypes.h"
+#include <wtf/Seconds.h>
 
 namespace WebCore {
 
@@ -38,16 +39,16 @@
 
 class ScrollingMomentumCalculator {
 public:
-    ScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity);
-    static std::unique_ptr<ScrollingMomentumCalculator> create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity);
+    ScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
+    static std::unique_ptr<ScrollingMomentumCalculator> create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
     virtual ~ScrollingMomentumCalculator() { }
 
-    virtual FloatPoint scrollOffsetAfterElapsedTime(double time) = 0;
-    virtual double animationDuration() = 0;
+    virtual FloatPoint scrollOffsetAfterElapsedTime(Seconds) = 0;
+    virtual Seconds animationDuration() = 0;
 
 protected:
     FloatSize m_initialDelta;
-    FloatPoint m_initialVelocity;
+    FloatSize m_initialVelocity;
     FloatSize m_initialScrollOffset;
     FloatSize m_targetScrollOffset;
     FloatSize m_viewportSize;
@@ -56,14 +57,14 @@
 
 class BasicScrollingMomentumCalculator final : public ScrollingMomentumCalculator {
 public:
-    BasicScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity);
+    BasicScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
 
 private:
-    FloatPoint scrollOffsetAfterElapsedTime(double seconds) final;
-    double animationDuration() final;
+    FloatPoint scrollOffsetAfterElapsedTime(Seconds) final;
+    Seconds animationDuration() final;
     void initializeInterpolationCoefficientsIfNecessary();
     void initializeSnapProgressCurve();
-    float animationProgressAfterElapsedTime(double time) const;
+    float animationProgressAfterElapsedTime(Seconds) const;
     FloatSize linearlyInterpolatedOffsetAtProgress(float progress) const;
     FloatSize cubicallyInterpolatedOffsetAtProgress(float progress) const;
 

Modified: trunk/Source/WebCore/page/scrolling/mac/ScrollingMomentumCalculatorMac.h (209086 => 209087)


--- trunk/Source/WebCore/page/scrolling/mac/ScrollingMomentumCalculatorMac.h	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/scrolling/mac/ScrollingMomentumCalculatorMac.h	2016-11-29 21:12:26 UTC (rev 209087)
@@ -36,11 +36,11 @@
 
 class ScrollingMomentumCalculatorMac final : public ScrollingMomentumCalculator {
 public:
-    ScrollingMomentumCalculatorMac(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity);
+    ScrollingMomentumCalculatorMac(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
 
 private:
-    FloatPoint scrollOffsetAfterElapsedTime(double time) final;
-    double animationDuration() final;
+    FloatPoint scrollOffsetAfterElapsedTime(Seconds) final;
+    Seconds animationDuration() final;
     _NSScrollingMomentumCalculator *ensurePlatformMomentumCalculator();
 
     RetainPtr<_NSScrollingMomentumCalculator> m_platformMomentumCalculator;

Modified: trunk/Source/WebCore/page/scrolling/mac/ScrollingMomentumCalculatorMac.mm (209086 => 209087)


--- trunk/Source/WebCore/page/scrolling/mac/ScrollingMomentumCalculatorMac.mm	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/page/scrolling/mac/ScrollingMomentumCalculatorMac.mm	2016-11-29 21:12:26 UTC (rev 209087)
@@ -32,24 +32,24 @@
 
 namespace WebCore {
 
-std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity)
+std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
 {
     return std::make_unique<ScrollingMomentumCalculatorMac>(viewportSize, contentSize, initialOffset, targetOffset, initialDelta, initialVelocity);
 }
 
-ScrollingMomentumCalculatorMac::ScrollingMomentumCalculatorMac(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity)
+ScrollingMomentumCalculatorMac::ScrollingMomentumCalculatorMac(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
     : ScrollingMomentumCalculator(viewportSize, contentSize, initialOffset, targetOffset, initialDelta, initialVelocity)
 {
 }
 
-FloatPoint ScrollingMomentumCalculatorMac::scrollOffsetAfterElapsedTime(double time)
+FloatPoint ScrollingMomentumCalculatorMac::scrollOffsetAfterElapsedTime(Seconds elapsedTime)
 {
-    return [ensurePlatformMomentumCalculator() positionAfterDuration:time];
+    return [ensurePlatformMomentumCalculator() positionAfterDuration:elapsedTime.value()];
 }
 
-double ScrollingMomentumCalculatorMac::animationDuration()
+Seconds ScrollingMomentumCalculatorMac::animationDuration()
 {
-    return [ensurePlatformMomentumCalculator() durationUntilStop];
+    return Seconds([ensurePlatformMomentumCalculator() durationUntilStop]);
 }
 
 _NSScrollingMomentumCalculator *ScrollingMomentumCalculatorMac::ensurePlatformMomentumCalculator()
@@ -59,7 +59,8 @@
 
     NSPoint origin = NSMakePoint(m_initialScrollOffset.width(), m_initialScrollOffset.height());
     NSRect contentFrame = NSMakeRect(0, 0, m_contentSize.width(), m_contentSize.height());
-    m_platformMomentumCalculator = adoptNS([[_NSScrollingMomentumCalculator alloc] initWithInitialOrigin:origin velocity:m_initialVelocity documentFrame:contentFrame constrainedClippingOrigin:NSZeroPoint clippingSize:m_viewportSize tolerance:NSMakeSize(1, 1)]);
+    NSPoint velocity = NSMakePoint(m_initialVelocity.width(), m_initialVelocity.height());
+    m_platformMomentumCalculator = adoptNS([[_NSScrollingMomentumCalculator alloc] initWithInitialOrigin:origin velocity:velocity documentFrame:contentFrame constrainedClippingOrigin:NSZeroPoint clippingSize:m_viewportSize tolerance:NSMakeSize(1, 1)]);
     [m_platformMomentumCalculator setDestinationOrigin:NSMakePoint(m_targetScrollOffset.width(), m_targetScrollOffset.height())];
 #if __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200
     [m_platformMomentumCalculator calculateToReachDestination];

Modified: trunk/Source/WebCore/platform/PlatformWheelEvent.h (209086 => 209087)


--- trunk/Source/WebCore/platform/PlatformWheelEvent.h	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/platform/PlatformWheelEvent.h	2016-11-29 21:12:26 UTC (rev 209087)
@@ -120,7 +120,7 @@
             return copy;
         }
 
-        PlatformWheelEvent copyWithDeltasAndVelocity(float deltaX, float deltaY, FloatPoint velocity) const
+        PlatformWheelEvent copyWithDeltasAndVelocity(float deltaX, float deltaY, const FloatSize& velocity) const
         {
             PlatformWheelEvent copy = *this;
             copy.m_deltaX = deltaX;
@@ -168,7 +168,7 @@
         bool useLatchedEventElement() const { return false; }
 #endif
 
-        FloatPoint scrollingVelocity() const { return m_scrollingVelocity; }
+        FloatSize scrollingVelocity() const { return m_scrollingVelocity; }
 
 #if PLATFORM(WIN)
         PlatformWheelEvent(HWND, WPARAM, LPARAM, bool isMouseHWheel);
@@ -184,7 +184,9 @@
         float m_wheelTicksY;
         PlatformWheelEventGranularity m_granularity;
         bool m_directionInvertedFromDevice;
-        FloatPoint m_scrollingVelocity;
+
+        // Scrolling velocity in pixels per second.
+        FloatSize m_scrollingVelocity;
 #if PLATFORM(COCOA)
         bool m_hasPreciseScrollingDeltas;
         PlatformWheelEventPhase m_phase;

Modified: trunk/Source/WebCore/platform/cocoa/ScrollController.h (209086 => 209087)


--- trunk/Source/WebCore/platform/cocoa/ScrollController.h	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/platform/cocoa/ScrollController.h	2016-11-29 21:12:26 UTC (rev 209087)
@@ -190,7 +190,7 @@
 #if ENABLE(CSS_SCROLL_SNAP)
     std::unique_ptr<ScrollSnapAnimatorState> m_scrollSnapState;
 #if PLATFORM(MAC)
-    FloatPoint m_dragEndedScrollingVelocity;
+    FloatSize m_dragEndedScrollingVelocity;
     RunLoop::Timer<ScrollController> m_statelessSnapTransitionTimer;
     RunLoop::Timer<ScrollController> m_scrollSnapTimer;
 #endif

Modified: trunk/Source/WebCore/platform/cocoa/ScrollController.mm (209086 => 209087)


--- trunk/Source/WebCore/platform/cocoa/ScrollController.mm	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/platform/cocoa/ScrollController.mm	2016-11-29 21:12:26 UTC (rev 209087)
@@ -514,8 +514,8 @@
     if (!m_scrollSnapState)
         return;
 
-    static const double statelessScrollSnapDelay = 0.75;
-    m_statelessSnapTransitionTimer.startOneShot(statelessScrollSnapDelay);
+    static const Seconds statelessScrollSnapDelay = 750_ms;
+    m_statelessSnapTransitionTimer.startOneShot(statelessScrollSnapDelay.value());
     startDeferringTestsDueToScrollSnapping();
 }
 

Modified: trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.h (209086 => 209087)


--- trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.h	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.h	2016-11-29 21:12:26 UTC (rev 209087)
@@ -35,6 +35,7 @@
 #include "PlatformWheelEvent.h"
 #include "ScrollTypes.h"
 #include "ScrollingMomentumCalculator.h"
+#include <wtf/MonotonicTime.h>
 
 namespace WebCore {
 
@@ -79,7 +80,7 @@
 
     // State transition helpers.
     void transitionToSnapAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset);
-    void transitionToGlideAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatPoint& initialVelocity, const FloatSize& initialDelta);
+    void transitionToGlideAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta);
     void transitionToUserInteractionState();
     void transitionToDestinationReachedState();
 
@@ -86,7 +87,7 @@
 private:
     float targetOffsetForStartOffset(ScrollEventAxis, float maxScrollOffset, float startOffset, float pageScale, float delta, unsigned& outActiveSnapIndex) const;
     void teardownAnimationForState(ScrollSnapState);
-    void setupAnimationForState(ScrollSnapState, const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatPoint& initialVelocity, const FloatSize& initialDelta);
+    void setupAnimationForState(ScrollSnapState, const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta);
 
     ScrollSnapState m_currentState { ScrollSnapState::UserInteraction };
 
@@ -95,7 +96,7 @@
     Vector<LayoutUnit> m_snapOffsetsY;
     unsigned m_activeSnapIndexY { 0 };
 
-    double m_startTime { 0 };
+    MonotonicTime m_startTime;
     std::unique_ptr<ScrollingMomentumCalculator> m_momentumCalculator;
 };
 

Modified: trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.mm (209086 => 209087)


--- trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.mm	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.mm	2016-11-29 21:12:26 UTC (rev 209087)
@@ -25,7 +25,6 @@
 
 #include "config.h"
 #include "ScrollSnapAnimatorState.h"
-#include <wtf/CurrentTime.h>
 #include <wtf/MathExtras.h>
 
 #if ENABLE(CSS_SCROLL_SNAP)
@@ -43,12 +42,12 @@
     setupAnimationForState(ScrollSnapState::Snapping, contentSize, viewportSize, pageScale, initialOffset, { }, { });
 }
 
-void ScrollSnapAnimatorState::transitionToGlideAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatPoint& initialVelocity, const FloatSize& initialDelta)
+void ScrollSnapAnimatorState::transitionToGlideAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta)
 {
     setupAnimationForState(ScrollSnapState::Gliding, contentSize, viewportSize, pageScale, initialOffset, initialVelocity, initialDelta);
 }
 
-void ScrollSnapAnimatorState::setupAnimationForState(ScrollSnapState state, const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatPoint& initialVelocity, const FloatSize& initialDelta)
+void ScrollSnapAnimatorState::setupAnimationForState(ScrollSnapState state, const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta)
 {
     ASSERT(state == ScrollSnapState::Snapping || state == ScrollSnapState::Gliding);
     if (m_currentState == state)
@@ -57,7 +56,7 @@
     float targetOffsetX = targetOffsetForStartOffset(ScrollEventAxis::Horizontal, contentSize.width() - viewportSize.width(), initialOffset.x(), pageScale, initialDelta.width(), m_activeSnapIndexX);
     float targetOffsetY = targetOffsetForStartOffset(ScrollEventAxis::Vertical, contentSize.height() - viewportSize.height(), initialOffset.y(), pageScale, initialDelta.height(), m_activeSnapIndexY);
     m_momentumCalculator = ScrollingMomentumCalculator::create(viewportSize, contentSize, initialOffset, FloatPoint(targetOffsetX, targetOffsetY), initialDelta, initialVelocity);
-    m_startTime = monotonicallyIncreasingTime();
+    m_startTime = MonotonicTime::now();
     m_currentState = state;
 }
 
@@ -78,7 +77,7 @@
         return;
 
     m_momentumCalculator = nullptr;
-    m_startTime = 0;
+    m_startTime = MonotonicTime();
     m_currentState = state;
 }
 
@@ -89,7 +88,7 @@
         return { };
     }
 
-    double elapsedTime = monotonicallyIncreasingTime() - m_startTime;
+    Seconds elapsedTime = MonotonicTime::now() - m_startTime;
     isAnimationComplete = elapsedTime >= m_momentumCalculator->animationDuration();
     return m_momentumCalculator->scrollOffsetAfterElapsedTime(elapsedTime);
 }

Modified: trunk/Source/WebCore/platform/spi/mac/NSScrollingMomentumCalculatorSPI.h (209086 => 209087)


--- trunk/Source/WebCore/platform/spi/mac/NSScrollingMomentumCalculatorSPI.h	2016-11-29 21:08:12 UTC (rev 209086)
+++ trunk/Source/WebCore/platform/spi/mac/NSScrollingMomentumCalculatorSPI.h	2016-11-29 21:12:26 UTC (rev 209087)
@@ -31,7 +31,7 @@
 
 #else
 
-@interface _NSScrollingMomentumCalculator : NSObject;
+@interface _NSScrollingMomentumCalculator : NSObject
 
 - (instancetype)initWithInitialOrigin:(NSPoint)origin velocity:(NSPoint)velocity documentFrame:(NSRect)docFrame constrainedClippingOrigin:(NSPoint)constrainedClippingOrigin clippingSize:(NSSize)clipViewSize tolerance:(NSSize)tolerance;
 - (NSPoint)positionAfterDuration:(NSTimeInterval)duration;
@@ -39,7 +39,7 @@
 - (void)calculateToReachDestination;
 #endif
 
-@property (atomic) NSPoint destinationOrigin;
+@property NSPoint destinationOrigin;
 @property (readonly) NSTimeInterval durationUntilStop;
 
 @end
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to