Changeset 209087 in webkit


Ignore:
Timestamp:
Nov 29, 2016 1:12:26 PM (7 years ago)
Author:
Wenson Hsieh
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:
Location:
trunk/Source/WebCore
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r209086 r209087  
     12016-11-29  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        Address post-review feedback following r209070 (AppKit momentum scrolling adoption for scroll snapping)
     4        https://bugs.webkit.org/show_bug.cgi?id=165147
     5
     6        Reviewed by Simon Fraser.
     7
     8        Addresses some additional review feedback after r209070, which adopts _NSScrollingMomentumCalculator for scroll
     9        snapping. See individual changes below for more details. No new tests, since there is no behavior change.
     10
     11        * page/EventHandler.cpp:
     12        (WebCore::handleWheelEventInAppropriateEnclosingBox):
     13        (WebCore::EventHandler::defaultWheelEventHandler):
     14        * page/Page.cpp:
     15        (WebCore::Page::ensureTestTrigger):
     16        * page/WheelEventDeltaFilter.cpp:
     17        (WebCore::WheelEventDeltaFilter::filteredVelocity):
     18        * page/WheelEventDeltaFilter.h:
     19        * page/mac/WheelEventDeltaFilterMac.mm:
     20        (WebCore::WheelEventDeltaFilterMac::updateFromDelta):
     21        * page/scrolling/AsyncScrollingCoordinator.cpp:
     22        (WebCore::AsyncScrollingCoordinator::updateExpectsWheelEventTestTriggerWithFrameView):
     23        * page/scrolling/AsyncScrollingCoordinator.h:
     24        * page/scrolling/ScrollingCoordinator.h:
     25        (WebCore::ScrollingCoordinator::updateExpectsWheelEventTestTriggerWithFrameView):
     26
     27        Rather than force a complete layout pass when the Page first acquires a WheelEventTestTrigger, we now simply
     28        have the scrolling coordinator update its frame node to expect a wheel event test trigger.
     29
     30        * page/scrolling/ScrollingMomentumCalculator.cpp:
     31        (WebCore::ScrollingMomentumCalculator::ScrollingMomentumCalculator):
     32        (WebCore::ScrollingMomentumCalculator::create):
     33        (WebCore::BasicScrollingMomentumCalculator::BasicScrollingMomentumCalculator):
     34        (WebCore::BasicScrollingMomentumCalculator::scrollOffsetAfterElapsedTime):
     35        (WebCore::BasicScrollingMomentumCalculator::animationDuration):
     36        (WebCore::BasicScrollingMomentumCalculator::initializeSnapProgressCurve):
     37        (WebCore::BasicScrollingMomentumCalculator::animationProgressAfterElapsedTime):
     38        * page/scrolling/ScrollingMomentumCalculator.h:
     39        * page/scrolling/mac/ScrollingMomentumCalculatorMac.h:
     40        * page/scrolling/mac/ScrollingMomentumCalculatorMac.mm:
     41        (WebCore::ScrollingMomentumCalculator::create):
     42        (WebCore::ScrollingMomentumCalculatorMac::ScrollingMomentumCalculatorMac):
     43        (WebCore::ScrollingMomentumCalculatorMac::scrollOffsetAfterElapsedTime):
     44        (WebCore::ScrollingMomentumCalculatorMac::animationDuration):
     45        (WebCore::ScrollingMomentumCalculatorMac::ensurePlatformMomentumCalculator):
     46        * platform/PlatformWheelEvent.h:
     47        (WebCore::PlatformWheelEvent::copyWithDeltasAndVelocity):
     48        (WebCore::PlatformWheelEvent::scrollingVelocity):
     49
     50        Change scrolling velocity in PlatformWheelEvent to be a FloatSize instead of a FloatPoint. This change
     51        propagates to the ScrollController, where state variables and arguments pertaining to scrolling velocity are
     52        also now sizes instead of points.
     53
     54        * platform/cocoa/ScrollController.h:
     55        * platform/cocoa/ScrollController.mm:
     56        (WebCore::ScrollController::scheduleStatelessScrollSnap):
     57        * platform/cocoa/ScrollSnapAnimatorState.h:
     58        * platform/cocoa/ScrollSnapAnimatorState.mm:
     59        (WebCore::ScrollSnapAnimatorState::transitionToGlideAnimationState):
     60        (WebCore::ScrollSnapAnimatorState::setupAnimationForState):
     61        (WebCore::ScrollSnapAnimatorState::teardownAnimationForState):
     62        (WebCore::ScrollSnapAnimatorState::currentAnimatedScrollOffset):
     63
     64        Refactor elapsed time to be Seconds instead of double. Additionally, use MonotonicTime::now() instead of
     65        monotonicallyIncreasingTime(), and MonotonicTime instead of double for keeping track of the start time.
     66
     67        * platform/spi/mac/NSScrollingMomentumCalculatorSPI.h:
     68
    1692016-11-29  Brady Eidson  <beidson@apple.com>
    270

  • trunk/Source/WebCore/page/EventHandler.cpp

    r209070 r209087  
    304304}
    305305
    306 static inline bool handleWheelEventInAppropriateEnclosingBox(Node* startNode, WheelEvent& wheelEvent, Element** stopElement, const FloatSize& filteredPlatformDelta, const FloatPoint& filteredVelocity)
     306static inline bool handleWheelEventInAppropriateEnclosingBox(Node* startNode, WheelEvent& wheelEvent, Element** stopElement, const FloatSize& filteredPlatformDelta, const FloatSize& filteredVelocity)
    307307{
    308308    bool shouldHandleEvent = wheelEvent.deltaX() || wheelEvent.deltaY();
    … …  
    27592759
    27602760    FloatSize filteredPlatformDelta(wheelEvent.deltaX(), wheelEvent.deltaY());
    2761     FloatPoint filteredVelocity;
     2761    FloatSize filteredVelocity;
    27622762    if (const PlatformWheelEvent* platformWheelEvent = wheelEvent.wheelEvent()) {
    27632763        filteredPlatformDelta.setWidth(platformWheelEvent->deltaX());

  • trunk/Source/WebCore/page/Page.cpp

    r209070 r209087  
    19961996    if (!m_testTrigger) {
    19971997        m_testTrigger = adoptRef(new WheelEventTestTrigger());
    1998         if (auto* frameView = mainFrame().view())
    1999             frameView->layout();
     1998        // We need to update the scrolling coordinator so that the mainframe scrolling node can expect wheel event test triggers.
     1999        if (auto* frameView = mainFrame().view()) {
     2000            if (m_scrollingCoordinator)
     2001                m_scrollingCoordinator->updateExpectsWheelEventTestTriggerWithFrameView(*frameView);
     2002        }
    20002003    }
    20012004

  • trunk/Source/WebCore/page/WheelEventDeltaFilter.cpp

    r209070 r209087  
    6464}
    6565
    66 FloatPoint WheelEventDeltaFilter::filteredVelocity() const
     66FloatSize WheelEventDeltaFilter::filteredVelocity() const
    6767{
    6868    return m_currentFilteredVelocity;

  • trunk/Source/WebCore/page/WheelEventDeltaFilter.h

    r209070 r209087  
    2626#pragma once
    2727
    28 #include "FloatPoint.h"
    2928#include "FloatSize.h"
    3029#include <wtf/Deque.h>
    … …  
    4140    WEBCORE_EXPORT virtual void beginFilteringDeltas() = 0;
    4241    WEBCORE_EXPORT virtual void endFilteringDeltas() = 0;
    43     WEBCORE_EXPORT FloatPoint filteredVelocity() const;
     42    WEBCORE_EXPORT FloatSize filteredVelocity() const;
    4443    WEBCORE_EXPORT bool isFilteringDeltas() const;
    4544    WEBCORE_EXPORT FloatSize filteredDelta() const;
    … …  
    4746protected:
    4847    FloatSize m_currentFilteredDelta;
    49     FloatPoint m_currentFilteredVelocity;
     48    FloatSize m_currentFilteredVelocity;
    5049    bool m_isFilteringDeltas { false };
    5150};

  • trunk/Source/WebCore/page/mac/WheelEventDeltaFilterMac.mm

    r209070 r209087  
    5656    NSPoint filteredVelocityResult;
    5757    [m_predominantAxisFilter filterInputDelta:NSPoint(FloatPoint(delta.width(), delta.height())) timestamp:monotonicallyIncreasingTime() - m_beginFilteringDeltasTime outputDelta:&filteredDeltaResult velocity:&filteredVelocityResult];
    58     m_currentFilteredVelocity = FloatPoint(filteredVelocityResult);
     58    m_currentFilteredVelocity = FloatSize(filteredVelocityResult.x, filteredVelocityResult.y);
    5959    m_currentFilteredDelta = FloatSize(filteredDeltaResult.x, filteredDeltaResult.y);
    6060}

  • trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp

    r208985 r209087  
    171171
    172172    node->setScrollableAreaParameters(scrollParameters);
     173}
     174
     175void AsyncScrollingCoordinator::updateExpectsWheelEventTestTriggerWithFrameView(const FrameView& frameView)
     176{
     177    auto* page = frameView.frame().page();
     178    if (!page)
     179        return;
     180
     181    auto* node = downcast<ScrollingStateFrameScrollingNode>(m_scrollingStateTree->stateNodeForID(frameView.scrollLayerID()));
     182    if (!node)
     183        return;
     184
     185    node->setExpectsWheelEventTestTrigger(page->expectsWheelEventTriggers());
    173186}
    174187

  • trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h

    r208985 r209087  
    6464    WEBCORE_EXPORT void updateScrollSnapPropertiesWithFrameView(const FrameView&) override;
    6565#endif
     66
     67    WEBCORE_EXPORT void updateExpectsWheelEventTestTriggerWithFrameView(const FrameView&) override;
    6668
    6769protected:

  • trunk/Source/WebCore/page/scrolling/ScrollingCoordinator.h

    r208985 r209087  
    207207
    208208    EventTrackingRegions absoluteEventTrackingRegions() const;
     209    virtual void updateExpectsWheelEventTestTriggerWithFrameView(const FrameView&) { }
    209210
    210211protected:

  • trunk/Source/WebCore/page/scrolling/ScrollingMomentumCalculator.cpp

    r209070 r209087  
    2929#include "FloatPoint.h"
    3030#include "FloatSize.h"
    31 #include <wtf/CurrentTime.h>
    3231
    3332namespace WebCore {
    3433
    35 static const double scrollSnapAnimationDuration = 1;
    36 
    37 ScrollingMomentumCalculator::ScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity)
     34static const Seconds scrollSnapAnimationDuration = 1_s;
     35
     36ScrollingMomentumCalculator::ScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
    3837    : m_initialDelta(initialDelta)
    3938    , m_initialVelocity(initialVelocity)
    … …  
    4746#if !HAVE(NSSCROLLING_FILTERS)
    4847
    49 std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity)
     48std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
    5049{
    5150    return std::make_unique<BasicScrollingMomentumCalculator>(viewportSize, contentSize, initialOffset, targetOffset, initialDelta, initialVelocity);
    … …  
    5453#endif
    5554
    56 BasicScrollingMomentumCalculator::BasicScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity)
     55BasicScrollingMomentumCalculator::BasicScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
    5756    : ScrollingMomentumCalculator(viewportSize, contentSize, initialOffset, targetOffset, initialDelta, initialVelocity)
    5857{
    … …  
    7473}
    7574
    76 FloatPoint BasicScrollingMomentumCalculator::scrollOffsetAfterElapsedTime(double seconds)
     75FloatPoint BasicScrollingMomentumCalculator::scrollOffsetAfterElapsedTime(Seconds elapsedTime)
    7776{
    7877    if (m_momentumCalculatorRequiresInitialization) {
    … …  
    8281    }
    8382
    84     float progress = animationProgressAfterElapsedTime(seconds);
     83    float progress = animationProgressAfterElapsedTime(elapsedTime);
    8584    auto offsetAsSize = m_forceLinearAnimationCurve ? linearlyInterpolatedOffsetAtProgress(progress) : cubicallyInterpolatedOffsetAtProgress(progress);
    8685    return FloatPoint(offsetAsSize.width(), offsetAsSize.height());
    8786}
    8887
    89 double BasicScrollingMomentumCalculator::animationDuration()
     88Seconds BasicScrollingMomentumCalculator::animationDuration()
    9089{
    9190    return scrollSnapAnimationDuration;
    … …  
    192191    for (int i = 0; i < maxNumScrollSnapParameterEstimationIterations; ++i) {
    193192        m_snapAnimationDecayFactor = m_snapAnimationCurveMagnitude / (m_snapAnimationCurveMagnitude - initialProgress);
    194         m_snapAnimationCurveMagnitude = 1.0f / (1.0f - std::pow(m_snapAnimationDecayFactor, -framesPerSecond * scrollSnapAnimationDuration));
     193        m_snapAnimationCurveMagnitude = 1.0f / (1.0f - std::pow(m_snapAnimationDecayFactor, -framesPerSecond * scrollSnapAnimationDuration.value()));
    195194        if (std::abs(m_snapAnimationDecayFactor - previousDecayFactor) < scrollSnapDecayFactorConvergenceThreshold)
    196195            break;
    … …  
    200199}
    201200
    202 float BasicScrollingMomentumCalculator::animationProgressAfterElapsedTime(double seconds) const
    203 {
    204     float timeProgress = clampTo<float>(seconds / scrollSnapAnimationDuration, 0, 1);
    205     return std::min(1.0, m_snapAnimationCurveMagnitude * (1.0 - std::pow(m_snapAnimationDecayFactor, -framesPerSecond * scrollSnapAnimationDuration * timeProgress)));
     201float BasicScrollingMomentumCalculator::animationProgressAfterElapsedTime(Seconds elapsedTime) const
     202{
     203    float timeProgress = clampTo<float>(elapsedTime / scrollSnapAnimationDuration, 0, 1);
     204    return std::min(1.0, m_snapAnimationCurveMagnitude * (1.0 - std::pow(m_snapAnimationDecayFactor, -framesPerSecond * scrollSnapAnimationDuration.value() * timeProgress)));
    206205}
    207206

  • trunk/Source/WebCore/page/scrolling/ScrollingMomentumCalculator.h

    r209070 r209087  
    3131#include "PlatformWheelEvent.h"
    3232#include "ScrollTypes.h"
     33#include <wtf/Seconds.h>
    3334
    3435namespace WebCore {
    … …  
    3940class ScrollingMomentumCalculator {
    4041public:
    41     ScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity);
    42     static std::unique_ptr<ScrollingMomentumCalculator> create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity);
     42    ScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
     43    static std::unique_ptr<ScrollingMomentumCalculator> create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
    4344    virtual ~ScrollingMomentumCalculator() { }
    4445
    45     virtual FloatPoint scrollOffsetAfterElapsedTime(double time) = 0;
    46     virtual double animationDuration() = 0;
     46    virtual FloatPoint scrollOffsetAfterElapsedTime(Seconds) = 0;
     47    virtual Seconds animationDuration() = 0;
    4748
    4849protected:
    4950    FloatSize m_initialDelta;
    50     FloatPoint m_initialVelocity;
     51    FloatSize m_initialVelocity;
    5152    FloatSize m_initialScrollOffset;
    5253    FloatSize m_targetScrollOffset;
    … …  
    5758class BasicScrollingMomentumCalculator final : public ScrollingMomentumCalculator {
    5859public:
    59     BasicScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity);
     60    BasicScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
    6061
    6162private:
    62     FloatPoint scrollOffsetAfterElapsedTime(double seconds) final;
    63     double animationDuration() final;
     63    FloatPoint scrollOffsetAfterElapsedTime(Seconds) final;
     64    Seconds animationDuration() final;
    6465    void initializeInterpolationCoefficientsIfNecessary();
    6566    void initializeSnapProgressCurve();
    66     float animationProgressAfterElapsedTime(double time) const;
     67    float animationProgressAfterElapsedTime(Seconds) const;
    6768    FloatSize linearlyInterpolatedOffsetAtProgress(float progress) const;
    6869    FloatSize cubicallyInterpolatedOffsetAtProgress(float progress) const;

  • trunk/Source/WebCore/page/scrolling/mac/ScrollingMomentumCalculatorMac.h

    r209070 r209087  
    3737class ScrollingMomentumCalculatorMac final : public ScrollingMomentumCalculator {
    3838public:
    39     ScrollingMomentumCalculatorMac(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity);
     39    ScrollingMomentumCalculatorMac(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
    4040
    4141private:
    42     FloatPoint scrollOffsetAfterElapsedTime(double time) final;
    43     double animationDuration() final;
     42    FloatPoint scrollOffsetAfterElapsedTime(Seconds) final;
     43    Seconds animationDuration() final;
    4444    _NSScrollingMomentumCalculator *ensurePlatformMomentumCalculator();
    4545

  • trunk/Source/WebCore/page/scrolling/mac/ScrollingMomentumCalculatorMac.mm

    r209071 r209087  
    3333namespace WebCore {
    3434
    35 std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity)
     35std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
    3636{
    3737    return std::make_unique<ScrollingMomentumCalculatorMac>(viewportSize, contentSize, initialOffset, targetOffset, initialDelta, initialVelocity);
    3838}
    3939
    40 ScrollingMomentumCalculatorMac::ScrollingMomentumCalculatorMac(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatPoint& initialVelocity)
     40ScrollingMomentumCalculatorMac::ScrollingMomentumCalculatorMac(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatPoint& targetOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
    4141    : ScrollingMomentumCalculator(viewportSize, contentSize, initialOffset, targetOffset, initialDelta, initialVelocity)
    4242{
    4343}
    4444
    45 FloatPoint ScrollingMomentumCalculatorMac::scrollOffsetAfterElapsedTime(double time)
     45FloatPoint ScrollingMomentumCalculatorMac::scrollOffsetAfterElapsedTime(Seconds elapsedTime)
    4646{
    47     return [ensurePlatformMomentumCalculator() positionAfterDuration:time];
     47    return [ensurePlatformMomentumCalculator() positionAfterDuration:elapsedTime.value()];
    4848}
    4949
    50 double ScrollingMomentumCalculatorMac::animationDuration()
     50Seconds ScrollingMomentumCalculatorMac::animationDuration()
    5151{
    52     return [ensurePlatformMomentumCalculator() durationUntilStop];
     52    return Seconds([ensurePlatformMomentumCalculator() durationUntilStop]);
    5353}
    5454
    … …  
    6060    NSPoint origin = NSMakePoint(m_initialScrollOffset.width(), m_initialScrollOffset.height());
    6161    NSRect contentFrame = NSMakeRect(0, 0, m_contentSize.width(), m_contentSize.height());
    62     m_platformMomentumCalculator = adoptNS([[_NSScrollingMomentumCalculator alloc] initWithInitialOrigin:origin velocity:m_initialVelocity documentFrame:contentFrame constrainedClippingOrigin:NSZeroPoint clippingSize:m_viewportSize tolerance:NSMakeSize(1, 1)]);
     62    NSPoint velocity = NSMakePoint(m_initialVelocity.width(), m_initialVelocity.height());
     63    m_platformMomentumCalculator = adoptNS([[_NSScrollingMomentumCalculator alloc] initWithInitialOrigin:origin velocity:velocity documentFrame:contentFrame constrainedClippingOrigin:NSZeroPoint clippingSize:m_viewportSize tolerance:NSMakeSize(1, 1)]);
    6364    [m_platformMomentumCalculator setDestinationOrigin:NSMakePoint(m_targetScrollOffset.width(), m_targetScrollOffset.height())];
    6465#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200

  • trunk/Source/WebCore/platform/PlatformWheelEvent.h

    r209070 r209087  
    121121        }
    122122
    123         PlatformWheelEvent copyWithDeltasAndVelocity(float deltaX, float deltaY, FloatPoint velocity) const
     123        PlatformWheelEvent copyWithDeltasAndVelocity(float deltaX, float deltaY, const FloatSize& velocity) const
    124124        {
    125125            PlatformWheelEvent copy = *this;
    … …  
    169169#endif
    170170
    171         FloatPoint scrollingVelocity() const { return m_scrollingVelocity; }
     171        FloatSize scrollingVelocity() const { return m_scrollingVelocity; }
    172172
    173173#if PLATFORM(WIN)
    … …  
    185185        PlatformWheelEventGranularity m_granularity;
    186186        bool m_directionInvertedFromDevice;
    187         FloatPoint m_scrollingVelocity;
     187
     188        // Scrolling velocity in pixels per second.
     189        FloatSize m_scrollingVelocity;
    188190#if PLATFORM(COCOA)
    189191        bool m_hasPreciseScrollingDeltas;

  • trunk/Source/WebCore/platform/cocoa/ScrollController.h

    r209070 r209087  
    191191    std::unique_ptr<ScrollSnapAnimatorState> m_scrollSnapState;
    192192#if PLATFORM(MAC)
    193     FloatPoint m_dragEndedScrollingVelocity;
     193    FloatSize m_dragEndedScrollingVelocity;
    194194    RunLoop::Timer<ScrollController> m_statelessSnapTransitionTimer;
    195195    RunLoop::Timer<ScrollController> m_scrollSnapTimer;

  • trunk/Source/WebCore/platform/cocoa/ScrollController.mm

    r209070 r209087  
    515515        return;
    516516
    517     static const double statelessScrollSnapDelay = 0.75;
    518     m_statelessSnapTransitionTimer.startOneShot(statelessScrollSnapDelay);
     517    static const Seconds statelessScrollSnapDelay = 750_ms;
     518    m_statelessSnapTransitionTimer.startOneShot(statelessScrollSnapDelay.value());
    519519    startDeferringTestsDueToScrollSnapping();
    520520}

  • trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.h

    r209070 r209087  
    3636#include "ScrollTypes.h"
    3737#include "ScrollingMomentumCalculator.h"
     38#include <wtf/MonotonicTime.h>
    3839
    3940namespace WebCore {
    … …  
    8081    // State transition helpers.
    8182    void transitionToSnapAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset);
    82     void transitionToGlideAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatPoint& initialVelocity, const FloatSize& initialDelta);
     83    void transitionToGlideAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta);
    8384    void transitionToUserInteractionState();
    8485    void transitionToDestinationReachedState();
    … …  
    8788    float targetOffsetForStartOffset(ScrollEventAxis, float maxScrollOffset, float startOffset, float pageScale, float delta, unsigned& outActiveSnapIndex) const;
    8889    void teardownAnimationForState(ScrollSnapState);
    89     void setupAnimationForState(ScrollSnapState, const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatPoint& initialVelocity, const FloatSize& initialDelta);
     90    void setupAnimationForState(ScrollSnapState, const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta);
    9091
    9192    ScrollSnapState m_currentState { ScrollSnapState::UserInteraction };
    … …  
    9697    unsigned m_activeSnapIndexY { 0 };
    9798
    98     double m_startTime { 0 };
     99    MonotonicTime m_startTime;
    99100    std::unique_ptr<ScrollingMomentumCalculator> m_momentumCalculator;
    100101};

  • trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.mm

    r209070 r209087  
    2626#include "config.h"
    2727#include "ScrollSnapAnimatorState.h"
    28 #include <wtf/CurrentTime.h>
    2928#include <wtf/MathExtras.h>
    3029
    … …  
    4443}
    4544
    46 void ScrollSnapAnimatorState::transitionToGlideAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatPoint& initialVelocity, const FloatSize& initialDelta)
     45void ScrollSnapAnimatorState::transitionToGlideAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta)
    4746{
    4847    setupAnimationForState(ScrollSnapState::Gliding, contentSize, viewportSize, pageScale, initialOffset, initialVelocity, initialDelta);
    4948}
    5049
    51 void ScrollSnapAnimatorState::setupAnimationForState(ScrollSnapState state, const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatPoint& initialVelocity, const FloatSize& initialDelta)
     50void ScrollSnapAnimatorState::setupAnimationForState(ScrollSnapState state, const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta)
    5251{
    5352    ASSERT(state == ScrollSnapState::Snapping || state == ScrollSnapState::Gliding);
    … …  
    5857    float targetOffsetY = targetOffsetForStartOffset(ScrollEventAxis::Vertical, contentSize.height() - viewportSize.height(), initialOffset.y(), pageScale, initialDelta.height(), m_activeSnapIndexY);
    5958    m_momentumCalculator = ScrollingMomentumCalculator::create(viewportSize, contentSize, initialOffset, FloatPoint(targetOffsetX, targetOffsetY), initialDelta, initialVelocity);
    60     m_startTime = monotonicallyIncreasingTime();
     59    m_startTime = MonotonicTime::now();
    6160    m_currentState = state;
    6261}
    … …  
    7978
    8079    m_momentumCalculator = nullptr;
    81     m_startTime = 0;
     80    m_startTime = MonotonicTime();
    8281    m_currentState = state;
    8382}
    … …  
    9089    }
    9190
    92     double elapsedTime = monotonicallyIncreasingTime() - m_startTime;
     91    Seconds elapsedTime = MonotonicTime::now() - m_startTime;
    9392    isAnimationComplete = elapsedTime >= m_momentumCalculator->animationDuration();
    9493    return m_momentumCalculator->scrollOffsetAfterElapsedTime(elapsedTime);

  • trunk/Source/WebCore/platform/spi/mac/NSScrollingMomentumCalculatorSPI.h

    r209071 r209087  
    3232#else
    3333
    34 @interface _NSScrollingMomentumCalculator : NSObject;
     34@interface _NSScrollingMomentumCalculator : NSObject
    3535
    3636- (instancetype)initWithInitialOrigin:(NSPoint)origin velocity:(NSPoint)velocity documentFrame:(NSRect)docFrame constrainedClippingOrigin:(NSPoint)constrainedClippingOrigin clippingSize:(NSSize)clipViewSize tolerance:(NSSize)tolerance;
    … …  
    4040#endif
    4141
    42 @property (atomic) NSPoint destinationOrigin;
     42@property NSPoint destinationOrigin;
    4343@property (readonly) NSTimeInterval durationUntilStop;
    4444
Note: See TracChangeset for help on using the changeset viewer.