Attachment #247737 for bug #142205

View Details Raw Unified Return to Bug 142205



2015-03-02  Commit Queue  <commit-queue@webkit.org>

        Unreviewed, rolling out r180902.
        https://bugs.webkit.org/show_bug.cgi?id=142205

        It broke scrolling in some cases. See bug 142202 for details.
        (Requested by bdash on #webkit).

        Reverted changeset:

        "Move scroll animating functions from ScrollAnimator to
        ScrollController"
        https://bugs.webkit.org/show_bug.cgi?id=142102
        http://trac.webkit.org/changeset/180902

2015-03-02  Yoav Weiss  <yoav@yoav.ws>

        Add a microtask abstraction



    
    bool didHandleEvent = view ? view->wheelEvent(wheelEvent) : false;
    m_isHandlingWheelEvent = false;
    
#if ENABLE(CSS_SCROLL_SNAP)
    if (scrollableArea)
        platformNotifySnapIfNecessary(wheelEvent, *scrollableArea);
#endif

    return didHandleEvent;
}




    virtual IntPoint absoluteScrollPosition() override;
    virtual void immediateScrollBy(const FloatSize&) override;
    virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) override;
    virtual void startSnapRubberbandTimer() override;
    virtual void stopSnapRubberbandTimer() override;
    virtual void adjustScrollPositionToBoundsIfNecessary() override;

    virtual FloatPoint scrollPosition() const override;


    bool isAlreadyPinnedInDirectionOfGesture(const PlatformWheelEvent&, ScrollEventAxis);

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
    LayoutUnit scrollOffsetOnAxis(ScrollEventAxis) override;
    void immediateScrollOnAxis(ScrollEventAxis, float delta) override;
#endif

    void logExposedUnfilledArea();

    ScrollController m_scrollController;
    RetainPtr<CFRunLoopTimerRef> m_snapRubberbandTimer;

    RetainPtr<CALayer> m_scrollLayer;
    RetainPtr<CALayer> m_scrolledContentsLayer;




ScrollingTreeFrameScrollingNodeMac::~ScrollingTreeFrameScrollingNodeMac()
{
    if (m_snapRubberbandTimer)
        CFRunLoopTimerInvalidate(m_snapRubberbandTimer.get());
}

void ScrollingTreeFrameScrollingNodeMac::updateBeforeChildren(const ScrollingStateNode& stateNode)

    scrollByWithoutContentEdgeConstraints(offset);
}

void ScrollingTreeFrameScrollingNodeMac::startSnapRubberbandTimer()
{
    ASSERT(!m_snapRubberbandTimer);

    CFTimeInterval timerInterval = 1.0 / 60.0;

    m_snapRubberbandTimer = adoptCF(CFRunLoopTimerCreateWithHandler(kCFAllocatorDefault, CFAbsoluteTimeGetCurrent() + timerInterval, timerInterval, 0, 0, ^(CFRunLoopTimerRef) {
        m_scrollController.snapRubberBandTimerFired();
    }));
    CFRunLoopAddTimer(CFRunLoopGetCurrent(), m_snapRubberbandTimer.get(), kCFRunLoopDefaultMode);
}

void ScrollingTreeFrameScrollingNodeMac::stopSnapRubberbandTimer()
{
    if (!m_snapRubberbandTimer)
        return;

    scrollingTree().setMainFrameIsRubberBanding(false);

    // Since the rubberband timer has stopped, totalContentsSizeForRubberBand can be synchronized with totalContentsSize.
    setTotalContentsSizeForRubberBand(totalContentsSize());

    CFRunLoopTimerInvalidate(m_snapRubberbandTimer.get());
    m_snapRubberbandTimer = nullptr;
}

void ScrollingTreeFrameScrollingNodeMac::adjustScrollPositionToBoundsIfNecessary()
{
    FloatPoint currentScrollPosition = absoluteScrollPosition();

    WTFLogAlways("SCROLLING: Wheel event handler count changed. Time: %f Count: %u\n", WTF::monotonicallyIncreasingTime(), count);
}

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
LayoutUnit ScrollingTreeFrameScrollingNodeMac::scrollOffsetOnAxis(ScrollEventAxis)
{
    // Temporary stub until http://webkit.org/b/141973.
    return 0;
}

void ScrollingTreeFrameScrollingNodeMac::immediateScrollOnAxis(ScrollEventAxis, float)
{
    // Temporary stub until http://webkit.org/b/141973.
}
#endif

} // namespace WebCore

#endif // ENABLE(ASYNC_SCROLLING) && PLATFORM(MAC)




ScrollAnimator::ScrollAnimator(ScrollableArea& scrollableArea)
    : m_scrollableArea(scrollableArea)
#if (ENABLE(CSS_SCROLL_SNAP) || ENABLE(RUBBER_BANDING)) && PLATFORM(MAC)
    , m_scrollController(this)
#endif
    , m_currentPosX(0)
    , m_currentPosY(0)
{

}

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
void ScrollAnimator::processWheelEventForScrollSnap(const PlatformWheelEvent& wheelEvent)
{
    if (m_verticalScrollSnapAnimator)
        m_verticalScrollSnapAnimator->handleWheelEvent(wheelEvent);
    if (m_horizontalScrollSnapAnimator)
        m_horizontalScrollSnapAnimator->handleWheelEvent(wheelEvent);
}
#endif

bool ScrollAnimator::handleWheelEvent(const PlatformWheelEvent& e)
{
#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
    if (m_verticalScrollSnapAnimator) {
        m_verticalScrollSnapAnimator->handleWheelEvent(e);
        if (m_verticalScrollSnapAnimator->shouldOverrideWheelEvent(e))
            return false;
    }
    if (m_horizontalScrollSnapAnimator) {
        m_horizontalScrollSnapAnimator->handleWheelEvent(e);
        if (m_horizontalScrollSnapAnimator->shouldOverrideWheelEvent(e))
            return false;
    }
#endif
#if PLATFORM(COCOA)
    // Events in the PlatformWheelEventPhaseMayBegin phase have no deltas, and therefore never passes through the scroll handling logic below.

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
void ScrollAnimator::updateScrollAnimatorsAndTimers()
{
    // FIXME: Currently, scroll snap animators are recreated even though the snap offsets alone can be updated.
    if (m_scrollableArea.horizontalSnapOffsets()) {
        m_horizontalScrollSnapAnimator = std::make_unique<AxisScrollSnapAnimator>(this, m_scrollableArea.horizontalSnapOffsets(), ScrollEventAxis::Horizontal);
        m_horizontalScrollSnapTimer = std::make_unique<Timer>(*this, &ScrollAnimator::horizontalScrollSnapTimerFired);
    } else if (m_horizontalScrollSnapAnimator) {
        m_horizontalScrollSnapAnimator = nullptr;
        m_horizontalScrollSnapTimer = nullptr;
    }
    if (m_scrollableArea.verticalSnapOffsets()) {
        m_verticalScrollSnapAnimator = std::make_unique<AxisScrollSnapAnimator>(this, m_scrollableArea.verticalSnapOffsets(), ScrollEventAxis::Vertical);
        m_verticalScrollSnapTimer = std::make_unique<Timer>(*this, &ScrollAnimator::verticalScrollSnapTimerFired);
    } else if (m_verticalScrollSnapAnimator) {
        m_verticalScrollSnapAnimator = nullptr;
        m_verticalScrollSnapTimer = nullptr;
    }
}

LayoutUnit ScrollAnimator::scrollOffsetInAxis(ScrollEventAxis axis)
{
    FloatPoint currentPosition = this->currentPosition();
    return axis == ScrollEventAxis::Horizontal ? currentPosition.x() : currentPosition.y();
}

void ScrollAnimator::immediateScrollInAxis(ScrollEventAxis axis, float delta)
{
    FloatPoint currentPosition = this->currentPosition();
    if (axis == ScrollEventAxis::Horizontal)

    else
        scrollToOffsetWithoutAnimation(FloatPoint(currentPosition.x(), currentPosition.y() + delta));
}

void ScrollAnimator::startScrollSnapTimer(ScrollEventAxis axis)
{
    Timer* scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer.get() : m_verticalScrollSnapTimer.get();
    if (!scrollSnapTimer->isActive())
        scrollSnapTimer->startRepeating(1.0 / 60.0);
}

void ScrollAnimator::stopScrollSnapTimer(ScrollEventAxis axis)
{
    Timer* scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer.get() : m_verticalScrollSnapTimer.get();
    if (scrollSnapTimer->isActive())
        scrollSnapTimer->stop();
}

void ScrollAnimator::horizontalScrollSnapTimerFired()
{
    m_horizontalScrollSnapAnimator->scrollSnapAnimationUpdate();
}

void ScrollAnimator::verticalScrollSnapTimerFired()
{
    m_verticalScrollSnapAnimator->scrollSnapAnimationUpdate();
}
#endif

} // namespace WebCore



#define ScrollAnimator_h

#include "FloatSize.h"
#include "LayoutUnit.h"
#include "PlatformWheelEvent.h"
#include "ScrollTypes.h"
#include <wtf/FastMalloc.h>
#include <wtf/Forward.h>

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
#include "AxisScrollSnapAnimator.h"
#include "Timer.h"
#endif

namespace WebCore {

class ScrollableArea;
class Scrollbar;

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
class ScrollAnimator : public AxisScrollSnapAnimatorClient {
#else
class ScrollAnimator {
#endif

    virtual bool isRubberBandInProgress() const { return false; }

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
    void processWheelEventForScrollSnap(const PlatformWheelEvent&);

    void updateScrollAnimatorsAndTimers();
    virtual LayoutUnit scrollOffsetInAxis(ScrollEventAxis) override;
    virtual void immediateScrollInAxis(ScrollEventAxis, float delta) override;
    virtual void startScrollSnapTimer(ScrollEventAxis) override;
    virtual void stopScrollSnapTimer(ScrollEventAxis) override;
#endif

protected:
    virtual void notifyPositionChanged(const FloatSize& delta);

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
    // Trivial wrappers around the actual update loop in AxisScrollSnapAnimator, since WebCore Timer requires a Timer argument.
    void horizontalScrollSnapTimerFired();
    void verticalScrollSnapTimerFired();
#endif

    ScrollableArea& m_scrollableArea;
    float m_currentPosX; // We avoid using a FloatPoint in order to reduce
    float m_currentPosY; // subclass code complexity.
#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
    std::unique_ptr<AxisScrollSnapAnimator> m_horizontalScrollSnapAnimator;
    std::unique_ptr<Timer> m_horizontalScrollSnapTimer;
    // FIXME: Find a way to consolidate both timers into one variable.
    std::unique_ptr<AxisScrollSnapAnimator> m_verticalScrollSnapAnimator;
    std::unique_ptr<Timer> m_verticalScrollSnapTimer;
#endif
};

} // namespace WebCore



/*
 * Copyright (C) 2011, 2014-2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef ScrollController_h
#define ScrollController_h

#if ENABLE(RUBBER_BANDING)

#include "FloatPoint.h"
#include "FloatSize.h"
#include "ScrollTypes.h"
#include <wtf/Noncopyable.h>
#include <wtf/RunLoop.h>

#if ENABLE(CSS_SCROLL_SNAP)
#include "AxisScrollSnapAnimator.h"
#endif

namespace WebCore {

class PlatformWheelEvent;
class ScrollableArea;

class ScrollControllerClient {
protected:
    virtual ~ScrollControllerClient() { }

public:
    virtual bool allowsHorizontalStretching(const PlatformWheelEvent&) = 0;
    virtual bool allowsVerticalStretching(const PlatformWheelEvent&) = 0;
    virtual IntSize stretchAmount() = 0;
    virtual bool pinnedInDirection(const FloatSize&) = 0;
    virtual bool canScrollHorizontally() = 0;
    virtual bool canScrollVertically() = 0;
    virtual bool shouldRubberBandInDirection(ScrollDirection) = 0;

    // Return the absolute scroll position, not relative to the scroll origin.
    virtual WebCore::IntPoint absoluteScrollPosition() = 0;

    virtual void immediateScrollBy(const FloatSize&) = 0;
    virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) = 0;

    // If the current scroll position is within the overhang area, this function will cause
    // the page to scroll to the nearest boundary point.
    virtual void adjustScrollPositionToBoundsIfNecessary() = 0;

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
    virtual LayoutUnit scrollOffsetOnAxis(ScrollEventAxis) = 0;
    virtual void immediateScrollOnAxis(ScrollEventAxis, float delta) = 0;
#endif
};

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
class ScrollController : public AxisScrollSnapAnimatorClient {
#else
class ScrollController {
#endif
    WTF_MAKE_NONCOPYABLE(ScrollController);

public:
    explicit ScrollController(ScrollControllerClient*);

    bool handleWheelEvent(const PlatformWheelEvent&);

    bool isRubberBandInProgress() const;

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
    bool processWheelEventForScrollSnap(const PlatformWheelEvent&);
    void updateScrollAnimatorsAndTimers(const ScrollableArea&);
#endif

private:
    void startSnapRubberbandTimer();
    void stopSnapRubberbandTimer();
    void snapRubberBand();
    void snapRubberBandTimerFired();

    bool shouldRubberBandInHorizontalDirection(const PlatformWheelEvent&);

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
    void horizontalScrollSnapTimerFired();
    void verticalScrollSnapTimerFired();
    void startScrollSnapTimer(ScrollEventAxis);
    void stopScrollSnapTimer(ScrollEventAxis);

    LayoutUnit scrollOffsetOnAxis(ScrollEventAxis) override;
    void immediateScrollOnAxis(ScrollEventAxis, float delta) override;
#endif

    ScrollControllerClient* m_client;
    
    CFTimeInterval m_lastMomentumScrollTimestamp;
    FloatSize m_overflowScrollDelta;
    FloatSize m_stretchScrollForce;
    FloatSize m_momentumVelocity;

    // Rubber band state.
    CFTimeInterval m_startTime;
    FloatSize m_startStretch;
    FloatPoint m_origOrigin;
    FloatSize m_origVelocity;
    RunLoop::Timer<ScrollController> m_snapRubberbandTimer;
    
#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
    // FIXME: Find a way to consolidate both timers into one variable.
    std::unique_ptr<AxisScrollSnapAnimator> m_horizontalScrollSnapAnimator;
    std::unique_ptr<AxisScrollSnapAnimator> m_verticalScrollSnapAnimator;
    RunLoop::Timer<ScrollController> m_horizontalScrollSnapTimer;
    RunLoop::Timer<ScrollController> m_verticalScrollSnapTimer;
#endif

    bool m_inScrollGesture;
    bool m_momentumScrollInProgress;
    bool m_ignoreMomentumScrolls;
    bool m_snapRubberbandTimerIsActive;
};

} // namespace WebCore

#endif // ENABLE(RUBBER_BANDING)

#endif // ScrollController_h



/*
 * Copyright (C) 2011, 2014-2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "ScrollController.h"

#include "PlatformWheelEvent.h"
#include "WebCoreSystemInterface.h"
#include <sys/sysctl.h>
#include <sys/time.h>

#if ENABLE(CSS_SCROLL_SNAP)
#include "AxisScrollSnapAnimator.h"
#include "ScrollableArea.h"
#endif

#if ENABLE(RUBBER_BANDING)

static NSTimeInterval systemUptime()
{
    if ([[NSProcessInfo processInfo] respondsToSelector:@selector(systemUptime)])
        return [[NSProcessInfo processInfo] systemUptime];

    // Get how long system has been up. Found by looking getting "boottime" from the kernel.
    static struct timeval boottime = {0, 0};
    if (!boottime.tv_sec) {
        int mib[2] = {CTL_KERN, KERN_BOOTTIME};
        size_t size = sizeof(boottime);
        if (-1 == sysctl(mib, 2, &boottime, &size, 0, 0))
            boottime.tv_sec = 0;
    }
    struct timeval now;
    if (boottime.tv_sec && -1 != gettimeofday(&now, 0)) {
        struct timeval uptime;
        timersub(&now, &boottime, &uptime);
        NSTimeInterval result = uptime.tv_sec + (uptime.tv_usec / 1E+6);
        return result;
    }
    return 0;
}


namespace WebCore {

static const float scrollVelocityZeroingTimeout = 0.10f;
static const float rubberbandDirectionLockStretchRatio = 1;
static const float rubberbandMinimumRequiredDeltaBeforeStretch = 10;

static float elasticDeltaForTimeDelta(float initialPosition, float initialVelocity, float elapsedTime)
{
    return wkNSElasticDeltaForTimeDelta(initialPosition, initialVelocity, elapsedTime);
}

static float elasticDeltaForReboundDelta(float delta)
{
    return wkNSElasticDeltaForReboundDelta(delta);
}

static float reboundDeltaForElasticDelta(float delta)
{
    return wkNSReboundDeltaForElasticDelta(delta);
}

static float scrollWheelMultiplier()
{
    static float multiplier = -1;
    if (multiplier < 0) {
        multiplier = [[NSUserDefaults standardUserDefaults] floatForKey:@"NSScrollWheelMultiplier"];
        if (multiplier <= 0)
            multiplier = 1;
    }
    return multiplier;
}

ScrollController::ScrollController(ScrollControllerClient* client)
    : m_client(client)
    , m_lastMomentumScrollTimestamp(0)
    , m_startTime(0)
    , m_snapRubberbandTimer(RunLoop::current(), this, &ScrollController::snapRubberBandTimerFired)
#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
    , m_horizontalScrollSnapTimer(RunLoop::current(), this, &ScrollController::horizontalScrollSnapTimerFired)
    , m_verticalScrollSnapTimer(RunLoop::current(), this, &ScrollController::verticalScrollSnapTimerFired)
#endif
    , m_inScrollGesture(false)
    , m_momentumScrollInProgress(false)
    , m_ignoreMomentumScrolls(false)
    , m_snapRubberbandTimerIsActive(false)
{
}

bool ScrollController::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
{
#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
    if (!processWheelEventForScrollSnap(wheelEvent))
        return false;
#endif
    if (wheelEvent.phase() == PlatformWheelEventPhaseBegan) {
        // First, check if we should rubber-band at all.
        if (m_client->pinnedInDirection(FloatSize(-wheelEvent.deltaX(), 0))
            && !shouldRubberBandInHorizontalDirection(wheelEvent))
            return false;

        m_inScrollGesture = true;
        m_momentumScrollInProgress = false;
        m_ignoreMomentumScrolls = false;
        m_lastMomentumScrollTimestamp = 0;
        m_momentumVelocity = FloatSize();

        IntSize stretchAmount = m_client->stretchAmount();
        m_stretchScrollForce.setWidth(reboundDeltaForElasticDelta(stretchAmount.width()));
        m_stretchScrollForce.setHeight(reboundDeltaForElasticDelta(stretchAmount.height()));
        m_overflowScrollDelta = FloatSize();

        stopSnapRubberbandTimer();

        return true;
    }

    if (wheelEvent.phase() == PlatformWheelEventPhaseEnded) {
        snapRubberBand();
        return true;
    }

    bool isMomentumScrollEvent = (wheelEvent.momentumPhase() != PlatformWheelEventPhaseNone);
    if (m_ignoreMomentumScrolls && (isMomentumScrollEvent || m_snapRubberbandTimerIsActive)) {
        if (wheelEvent.momentumPhase() == PlatformWheelEventPhaseEnded) {
            m_ignoreMomentumScrolls = false;
            return true;
        }
        return false;
    }

    float deltaX = m_overflowScrollDelta.width();
    float deltaY = m_overflowScrollDelta.height();

    // Reset overflow values because we may decide to remove delta at various points and put it into overflow.
    m_overflowScrollDelta = FloatSize();

    IntSize stretchAmount = m_client->stretchAmount();
    bool isVerticallyStretched = stretchAmount.height();
    bool isHorizontallyStretched = stretchAmount.width();

    float eventCoalescedDeltaX;
    float eventCoalescedDeltaY;

    if (isVerticallyStretched || isHorizontallyStretched) {
        eventCoalescedDeltaX = -wheelEvent.unacceleratedScrollingDeltaX();
        eventCoalescedDeltaY = -wheelEvent.unacceleratedScrollingDeltaY();
    } else {
        eventCoalescedDeltaX = -wheelEvent.deltaX();
        eventCoalescedDeltaY = -wheelEvent.deltaY();
    }

    deltaX += eventCoalescedDeltaX;
    deltaY += eventCoalescedDeltaY;

    // Slightly prefer scrolling vertically by applying the = case to deltaY
    if (fabsf(deltaY) >= fabsf(deltaX))
        deltaX = 0;
    else
        deltaY = 0;

    bool shouldStretch = false;

    PlatformWheelEventPhase momentumPhase = wheelEvent.momentumPhase();

    // If we are starting momentum scrolling then do some setup.
    if (!m_momentumScrollInProgress && (momentumPhase == PlatformWheelEventPhaseBegan || momentumPhase == PlatformWheelEventPhaseChanged))
        m_momentumScrollInProgress = true;

    CFTimeInterval timeDelta = wheelEvent.timestamp() - m_lastMomentumScrollTimestamp;
    if (m_inScrollGesture || m_momentumScrollInProgress) {
        if (m_lastMomentumScrollTimestamp && timeDelta > 0 && timeDelta < scrollVelocityZeroingTimeout) {
            m_momentumVelocity.setWidth(eventCoalescedDeltaX / (float)timeDelta);
            m_momentumVelocity.setHeight(eventCoalescedDeltaY / (float)timeDelta);
            m_lastMomentumScrollTimestamp = wheelEvent.timestamp();
        } else {
            m_lastMomentumScrollTimestamp = wheelEvent.timestamp();
            m_momentumVelocity = FloatSize();
        }

        if (isVerticallyStretched) {
            if (!isHorizontallyStretched && m_client->pinnedInDirection(FloatSize(deltaX, 0))) {
                // Stretching only in the vertical.
                if (deltaY && (fabsf(deltaX / deltaY) < rubberbandDirectionLockStretchRatio))
                    deltaX = 0;
                else if (fabsf(deltaX) < rubberbandMinimumRequiredDeltaBeforeStretch) {
                    m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
                    deltaX = 0;
                } else
                    m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
            }
        } else if (isHorizontallyStretched) {
            // Stretching only in the horizontal.
            if (m_client->pinnedInDirection(FloatSize(0, deltaY))) {
                if (deltaX && (fabsf(deltaY / deltaX) < rubberbandDirectionLockStretchRatio))
                    deltaY = 0;
                else if (fabsf(deltaY) < rubberbandMinimumRequiredDeltaBeforeStretch) {
                    m_overflowScrollDelta.setHeight(m_overflowScrollDelta.height() + deltaY);
                    deltaY = 0;
                } else
                    m_overflowScrollDelta.setHeight(m_overflowScrollDelta.height() + deltaY);
            }
        } else {
            // Not stretching at all yet.
            if (m_client->pinnedInDirection(FloatSize(deltaX, deltaY))) {
                if (fabsf(deltaY) >= fabsf(deltaX)) {
                    if (fabsf(deltaX) < rubberbandMinimumRequiredDeltaBeforeStretch) {
                        m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
                        deltaX = 0;
                    } else
                        m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
                }
                shouldStretch = true;
            }
        }
    }

    if (deltaX || deltaY) {
        if (!(shouldStretch || isVerticallyStretched || isHorizontallyStretched)) {
            if (deltaY) {
                deltaY *= scrollWheelMultiplier();
                m_client->immediateScrollBy(FloatSize(0, deltaY));
            }
            if (deltaX) {
                deltaX *= scrollWheelMultiplier();
                m_client->immediateScrollBy(FloatSize(deltaX, 0));
            }
        } else {
            if (!m_client->allowsHorizontalStretching(wheelEvent)) {
                deltaX = 0;
                eventCoalescedDeltaX = 0;
            } else if (deltaX && !isHorizontallyStretched && !m_client->pinnedInDirection(FloatSize(deltaX, 0))) {
                deltaX *= scrollWheelMultiplier();

                m_client->immediateScrollByWithoutContentEdgeConstraints(FloatSize(deltaX, 0));
                deltaX = 0;
            }

            if (!m_client->allowsVerticalStretching(wheelEvent)) {
                deltaY = 0;
                eventCoalescedDeltaY = 0;
            } else if (deltaY && !isVerticallyStretched && !m_client->pinnedInDirection(FloatSize(0, deltaY))) {
                deltaY *= scrollWheelMultiplier();

                m_client->immediateScrollByWithoutContentEdgeConstraints(FloatSize(0, deltaY));
                deltaY = 0;
            }

            IntSize stretchAmount = m_client->stretchAmount();

            if (m_momentumScrollInProgress) {
                if ((m_client->pinnedInDirection(FloatSize(eventCoalescedDeltaX, eventCoalescedDeltaY)) || (fabsf(eventCoalescedDeltaX) + fabsf(eventCoalescedDeltaY) <= 0)) && m_lastMomentumScrollTimestamp) {
                    m_ignoreMomentumScrolls = true;
                    m_momentumScrollInProgress = false;
                    snapRubberBand();
                }
            }

            m_stretchScrollForce.setWidth(m_stretchScrollForce.width() + deltaX);
            m_stretchScrollForce.setHeight(m_stretchScrollForce.height() + deltaY);

            FloatSize dampedDelta(ceilf(elasticDeltaForReboundDelta(m_stretchScrollForce.width())), ceilf(elasticDeltaForReboundDelta(m_stretchScrollForce.height())));

            m_client->immediateScrollByWithoutContentEdgeConstraints(dampedDelta - stretchAmount);
        }
    }

    if (m_momentumScrollInProgress && momentumPhase == PlatformWheelEventPhaseEnded) {
        m_momentumScrollInProgress = false;
        m_ignoreMomentumScrolls = false;
        m_lastMomentumScrollTimestamp = 0;
    }

    return true;
}

static inline float roundTowardZero(float num)
{
    return num > 0 ? ceilf(num - 0.5f) : floorf(num + 0.5f);
}

static inline float roundToDevicePixelTowardZero(float num)
{
    float roundedNum = roundf(num);
    if (fabs(num - roundedNum) < 0.125)
        num = roundedNum;

    return roundTowardZero(num);
}

void ScrollController::snapRubberBandTimerFired()
{
    if (!m_momentumScrollInProgress || m_ignoreMomentumScrolls) {
        CFTimeInterval timeDelta = [NSDate timeIntervalSinceReferenceDate] - m_startTime;

        if (m_startStretch == FloatSize()) {
            m_startStretch = m_client->stretchAmount();
            if (m_startStretch == FloatSize()) {
                stopSnapRubberbandTimer();

                m_stretchScrollForce = FloatSize();
                m_startTime = 0;
                m_startStretch = FloatSize();
                m_origOrigin = FloatPoint();
                m_origVelocity = FloatSize();
                return;
            }

            m_origOrigin = m_client->absoluteScrollPosition() - m_startStretch;
            m_origVelocity = m_momentumVelocity;

            // Just like normal scrolling, prefer vertical rubberbanding
            if (fabsf(m_origVelocity.height()) >= fabsf(m_origVelocity.width()))
                m_origVelocity.setWidth(0);

            // Don't rubber-band horizontally if it's not possible to scroll horizontally
            if (!m_client->canScrollHorizontally())
                m_origVelocity.setWidth(0);

            // Don't rubber-band vertically if it's not possible to scroll vertically
            if (!m_client->canScrollVertically())
                m_origVelocity.setHeight(0);
        }

        FloatPoint delta(roundToDevicePixelTowardZero(elasticDeltaForTimeDelta(m_startStretch.width(), -m_origVelocity.width(), (float)timeDelta)),
            roundToDevicePixelTowardZero(elasticDeltaForTimeDelta(m_startStretch.height(), -m_origVelocity.height(), (float)timeDelta)));

        if (fabs(delta.x()) >= 1 || fabs(delta.y()) >= 1) {
            m_client->immediateScrollByWithoutContentEdgeConstraints(FloatSize(delta.x(), delta.y()) - m_client->stretchAmount());

            FloatSize newStretch = m_client->stretchAmount();

            m_stretchScrollForce.setWidth(reboundDeltaForElasticDelta(newStretch.width()));
            m_stretchScrollForce.setHeight(reboundDeltaForElasticDelta(newStretch.height()));
        } else {
            m_client->adjustScrollPositionToBoundsIfNecessary();

            stopSnapRubberbandTimer();
            m_stretchScrollForce = FloatSize();
            m_startTime = 0;
            m_startStretch = FloatSize();
            m_origOrigin = FloatPoint();
            m_origVelocity = FloatSize();
        }
    } else {
        m_startTime = [NSDate timeIntervalSinceReferenceDate];
        m_startStretch = FloatSize();
    }
}

bool ScrollController::isRubberBandInProgress() const
{
    if (!m_inScrollGesture && !m_momentumScrollInProgress && !m_snapRubberbandTimerIsActive)
        return false;

    return !m_client->stretchAmount().isZero();
}

void ScrollController::startSnapRubberbandTimer()
{
    m_snapRubberbandTimer.startRepeating(1.0 / 60.0);
}

void ScrollController::stopSnapRubberbandTimer()
{
    m_snapRubberbandTimer.stop();
    m_snapRubberbandTimerIsActive = false;
}

void ScrollController::snapRubberBand()
{
    CFTimeInterval timeDelta = systemUptime() - m_lastMomentumScrollTimestamp;
    if (m_lastMomentumScrollTimestamp && timeDelta >= scrollVelocityZeroingTimeout)
        m_momentumVelocity = FloatSize();

    m_inScrollGesture = false;

    if (m_snapRubberbandTimerIsActive)
        return;

    m_startTime = [NSDate timeIntervalSinceReferenceDate];
    m_startStretch = FloatSize();
    m_origOrigin = FloatPoint();
    m_origVelocity = FloatSize();

    startSnapRubberbandTimer();
    m_snapRubberbandTimerIsActive = true;
}

bool ScrollController::shouldRubberBandInHorizontalDirection(const PlatformWheelEvent& wheelEvent)
{
    if (wheelEvent.deltaX() > 0)
        return m_client->shouldRubberBandInDirection(ScrollLeft);
    if (wheelEvent.deltaX() < 0)
        return m_client->shouldRubberBandInDirection(ScrollRight);

    return true;
}

#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
bool ScrollController::processWheelEventForScrollSnap(const PlatformWheelEvent& wheelEvent)
{
    if (m_verticalScrollSnapAnimator) {
        m_verticalScrollSnapAnimator->handleWheelEvent(wheelEvent);
        if (m_verticalScrollSnapAnimator->shouldOverrideWheelEvent(wheelEvent))
            return false;
    }
    if (m_horizontalScrollSnapAnimator) {
        m_horizontalScrollSnapAnimator->handleWheelEvent(wheelEvent);
        if (m_horizontalScrollSnapAnimator->shouldOverrideWheelEvent(wheelEvent))
            return false;
    }

    return true;
}
    
void ScrollController::updateScrollAnimatorsAndTimers(const ScrollableArea& scrollableArea)
{
    // FIXME: Currently, scroll snap animators are recreated even though the snap offsets alone can be updated.
    if (scrollableArea.horizontalSnapOffsets())
        m_horizontalScrollSnapAnimator = std::make_unique<AxisScrollSnapAnimator>(this, scrollableArea.horizontalSnapOffsets(), ScrollEventAxis::Horizontal);
    else if (m_horizontalScrollSnapAnimator)
        m_horizontalScrollSnapAnimator = nullptr;

    if (scrollableArea.verticalSnapOffsets())
        m_verticalScrollSnapAnimator = std::make_unique<AxisScrollSnapAnimator>(this, scrollableArea.verticalSnapOffsets(), ScrollEventAxis::Vertical);
    else if (m_verticalScrollSnapAnimator)
        m_verticalScrollSnapAnimator = nullptr;
}

void ScrollController::startScrollSnapTimer(ScrollEventAxis axis)
{
    RunLoop::Timer<ScrollController>& scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer : m_verticalScrollSnapTimer;
    if (!scrollSnapTimer.isActive())
        scrollSnapTimer.startRepeating(1.0 / 60.0);
}

void ScrollController::stopScrollSnapTimer(ScrollEventAxis axis)
{
    RunLoop::Timer<ScrollController>& scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer : m_verticalScrollSnapTimer;
    scrollSnapTimer.stop();
}
    
void ScrollController::horizontalScrollSnapTimerFired()
{
    if (m_horizontalScrollSnapAnimator)
        m_horizontalScrollSnapAnimator->scrollSnapAnimationUpdate();
}

void ScrollController::verticalScrollSnapTimerFired()
{
    if (m_verticalScrollSnapAnimator)
        m_verticalScrollSnapAnimator->scrollSnapAnimationUpdate();
}

LayoutUnit ScrollController::scrollOffsetOnAxis(ScrollEventAxis axis)
{
    return m_client->scrollOffsetOnAxis(axis);
}

void ScrollController::immediateScrollOnAxis(ScrollEventAxis axis, float delta)
{
    m_client->immediateScrollOnAxis(axis, delta);
}
#endif

} // namespace WebCore

#endif // ENABLE(RUBBER_BANDING)



    virtual ~AxisScrollSnapAnimatorClient() { }

public:
    virtual LayoutUnit scrollOffsetInAxis(ScrollEventAxis) = 0;
    virtual void immediateScrollInAxis(ScrollEventAxis, float velocity) = 0;
    virtual void startScrollSnapTimer(ScrollEventAxis) = 0;
    virtual void stopScrollSnapTimer(ScrollEventAxis) = 0;
};



        // Begin tracking wheel deltas for glide prediction.
        endScrollSnapAnimation(ScrollSnapState::UserInteraction);
        pushInitialWheelDelta(wheelDelta);
        m_beginTrackingWheelDeltaOffset = m_client->scrollOffsetInAxis(m_axis);
        break;

    case WheelEventStatus::InertialScrolling:

    ASSERT(m_currentState == ScrollSnapState::Gliding || m_currentState == ScrollSnapState::Snapping);
    float delta = m_currentState == ScrollSnapState::Snapping ? computeSnapDelta() : computeGlideDelta();
    if (delta)
        m_client->immediateScrollInAxis(m_axis, delta);
    else
        endScrollSnapAnimation(ScrollSnapState::DestinationReached);
}

void AxisScrollSnapAnimator::beginScrollSnapAnimation(ScrollSnapState newState)
{
    ASSERT(newState == ScrollSnapState::Gliding || newState == ScrollSnapState::Snapping);
    LayoutUnit offset = m_client->scrollOffsetInAxis(m_axis);
    float initialWheelDelta = newState == ScrollSnapState::Gliding ? averageInitialWheelDelta() : 0;
    LayoutUnit projectedScrollDestination = newState == ScrollSnapState::Gliding ? m_beginTrackingWheelDeltaOffset + LayoutUnit(projectedInertialScrollDistance(initialWheelDelta)) : offset;
    projectedScrollDestination = std::min(std::max(projectedScrollDestination, m_snapOffsets->first()), m_snapOffsets->last());

// relationship of the distance traveled, clamped by arbitrary min and max values.
float AxisScrollSnapAnimator::computeSnapDelta() const
{
    LayoutUnit offset = m_client->scrollOffsetInAxis(m_axis);
    bool canComputeSnap =  (m_initialOffset <= offset && offset < m_targetOffset) || (m_targetOffset < offset && offset <= m_initialOffset);
    if (m_currentState != ScrollSnapState::Snapping || !canComputeSnap)
        return 0;

// and VF. Thus, we can express our gliding equation all in terms of V0, VF and t.
float AxisScrollSnapAnimator::computeGlideDelta() const
{
    LayoutUnit offset = m_client->scrollOffsetInAxis(m_axis);
    bool canComputeGlide = (m_initialOffset <= offset && offset < m_targetOffset) || (m_targetOffset < offset && offset <= m_initialOffset);
    if (m_currentState != ScrollSnapState::Gliding || !canComputeGlide)
        return 0;

Lines 32-37 a/Source/WebCore/platform/mac/ScrollAnimatorMac.h_sec1
- a/Source/WebCore/platform/mac/ScrollAnimatorMac.h -1 / +12 lines
32	#include "FloatPoint.h"	32	#include "FloatPoint.h"
33	#include "FloatSize.h"	33	#include "FloatSize.h"
34	#include "ScrollAnimator.h"	34	#include "ScrollAnimator.h"
		35	#include "ScrollController.h"
35	#include "Timer.h"	36	#include "Timer.h"
36	#include <wtf/RetainPtr.h>	37	#include <wtf/RetainPtr.h>
37		38
Lines 41-51 OBJC_CLASS WebScrollbarPainterDelegate; a/Source/WebCore/platform/mac/ScrollAnimatorMac.h_sec2
41		42
42	typedef id ScrollbarPainterController;	43	typedef id ScrollbarPainterController;
43		44
		45	#if !ENABLE(RUBBER_BANDING)
		46	class ScrollControllerClient { };
		47	#endif
		48
44	namespace WebCore {	49	namespace WebCore {
45		50
46	class Scrollbar;	51	class Scrollbar;
47		52
48	class ScrollAnimatorMac : public ScrollAnimator {	53	class ScrollAnimatorMac : public ScrollAnimator, private ScrollControllerClient {
49		54
50	public:	55	public:
51	ScrollAnimatorMac(ScrollableArea&);	56	ScrollAnimatorMac(ScrollableArea&);
Lines 145-155 private: a/Source/WebCore/platform/mac/ScrollAnimatorMac.h_sec3
145	virtual WebCore::IntPoint absoluteScrollPosition() override;	150	virtual WebCore::IntPoint absoluteScrollPosition() override;
146	virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) override;	151	virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) override;
147	virtual void immediateScrollBy(const FloatSize&) override;	152	virtual void immediateScrollBy(const FloatSize&) override;
		153	virtual void startSnapRubberbandTimer() override;
		154	virtual void stopSnapRubberbandTimer() override;
148	virtual void adjustScrollPositionToBoundsIfNecessary() override;	155	virtual void adjustScrollPositionToBoundsIfNecessary() override;
149		156
150	bool pinnedInDirection(float deltaX, float deltaY);	157	bool pinnedInDirection(float deltaX, float deltaY);
		158	void snapRubberBandTimerFired();
151		159
152	bool isAlreadyPinnedInDirectionOfGesture(const PlatformWheelEvent&, ScrollEventAxis);	160	bool isAlreadyPinnedInDirectionOfGesture(const PlatformWheelEvent&, ScrollEventAxis);
		161
		162	ScrollController m_scrollController;
		163	Timer m_snapRubberBandTimer;
153	#endif	164	#endif
154		165
155	bool m_haveScrolledSincePageLoad;	166	bool m_haveScrolledSincePageLoad;



    : ScrollAnimator(scrollableArea)
    , m_initialScrollbarPaintTimer(*this, &ScrollAnimatorMac::initialScrollbarPaintTimerFired)
    , m_sendContentAreaScrolledTimer(*this, &ScrollAnimatorMac::sendContentAreaScrolledTimerFired)
#if ENABLE(RUBBER_BANDING)
    , m_scrollController(this)
    , m_snapRubberBandTimer(*this, &ScrollAnimatorMac::snapRubberBandTimerFired)
#endif
    , m_haveScrolledSincePageLoad(false)
    , m_needsScrollerStyleUpdate(false)
{

    m_currentPosY = newPos.y();
    notifyPositionChanged(adjustedDelta);
}

void ScrollAnimatorMac::startSnapRubberbandTimer()
{
    m_snapRubberBandTimer.startRepeating(1.0 / 60.0);
}

void ScrollAnimatorMac::stopSnapRubberbandTimer()
{
    m_snapRubberBandTimer.stop();
}

void ScrollAnimatorMac::snapRubberBandTimerFired()
{
    m_scrollController.snapRubberBandTimerFired();
}
#endif

void ScrollAnimatorMac::updateScrollerStyle()



/*
 * Copyright (C) 2011 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef ScrollController_h
#define ScrollController_h

#if ENABLE(RUBBER_BANDING)

#include "FloatPoint.h"
#include "FloatSize.h"
#include "ScrollTypes.h"
#include <wtf/Noncopyable.h>

namespace WebCore {

class PlatformWheelEvent;

class ScrollControllerClient {
protected:
    virtual ~ScrollControllerClient() { }

public:
    virtual bool allowsHorizontalStretching(const PlatformWheelEvent&) = 0;
    virtual bool allowsVerticalStretching(const PlatformWheelEvent&) = 0;
    virtual IntSize stretchAmount() = 0;
    virtual bool pinnedInDirection(const FloatSize&) = 0;
    virtual bool canScrollHorizontally() = 0;
    virtual bool canScrollVertically() = 0;
    virtual bool shouldRubberBandInDirection(ScrollDirection) = 0;

    // Return the absolute scroll position, not relative to the scroll origin.
    virtual WebCore::IntPoint absoluteScrollPosition() = 0;

    virtual void immediateScrollBy(const FloatSize&) = 0;
    virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) = 0;
    virtual void startSnapRubberbandTimer() = 0;
    virtual void stopSnapRubberbandTimer() = 0;

    // If the current scroll position is within the overhang area, this function will cause
    // the page to scroll to the nearest boundary point.
    virtual void adjustScrollPositionToBoundsIfNecessary() = 0;
};

class ScrollController {
    WTF_MAKE_NONCOPYABLE(ScrollController);

public:
    explicit ScrollController(ScrollControllerClient*);

    bool handleWheelEvent(const PlatformWheelEvent&);
    void snapRubberBandTimerFired();

    bool isRubberBandInProgress() const;

private:
    void stopSnapRubberbandTimer();
    void snapRubberBand();

    bool shouldRubberBandInHorizontalDirection(const PlatformWheelEvent&);

    ScrollControllerClient* m_client;

    bool m_inScrollGesture;
    bool m_momentumScrollInProgress;
    bool m_ignoreMomentumScrolls;
    
    CFTimeInterval m_lastMomentumScrollTimestamp;
    FloatSize m_overflowScrollDelta;
    FloatSize m_stretchScrollForce;
    FloatSize m_momentumVelocity;

    // Rubber band state.
    CFTimeInterval m_startTime;
    FloatSize m_startStretch;
    FloatPoint m_origOrigin;
    FloatSize m_origVelocity;

    bool m_snapRubberbandTimerIsActive;
};

} // namespace WebCore

#endif // ENABLE(RUBBER_BANDING)

#endif // ScrollController_h



/*
 * Copyright (C) 2011, 2014-2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "ScrollController.h"

#include "PlatformWheelEvent.h"
#include "WebCoreSystemInterface.h"
#include <sys/sysctl.h>
#include <sys/time.h>

#if ENABLE(RUBBER_BANDING)

static NSTimeInterval systemUptime()
{
    if ([[NSProcessInfo processInfo] respondsToSelector:@selector(systemUptime)])
        return [[NSProcessInfo processInfo] systemUptime];

    // Get how long system has been up. Found by looking getting "boottime" from the kernel.
    static struct timeval boottime = {0, 0};
    if (!boottime.tv_sec) {
        int mib[2] = {CTL_KERN, KERN_BOOTTIME};
        size_t size = sizeof(boottime);
        if (-1 == sysctl(mib, 2, &boottime, &size, 0, 0))
            boottime.tv_sec = 0;
    }
    struct timeval now;
    if (boottime.tv_sec && -1 != gettimeofday(&now, 0)) {
        struct timeval uptime;
        timersub(&now, &boottime, &uptime);
        NSTimeInterval result = uptime.tv_sec + (uptime.tv_usec / 1E+6);
        return result;
    }
    return 0;
}


namespace WebCore {

static const float scrollVelocityZeroingTimeout = 0.10f;
static const float rubberbandDirectionLockStretchRatio = 1;
static const float rubberbandMinimumRequiredDeltaBeforeStretch = 10;

static float elasticDeltaForTimeDelta(float initialPosition, float initialVelocity, float elapsedTime)
{
    return wkNSElasticDeltaForTimeDelta(initialPosition, initialVelocity, elapsedTime);
}

static float elasticDeltaForReboundDelta(float delta)
{
    return wkNSElasticDeltaForReboundDelta(delta);
}

static float reboundDeltaForElasticDelta(float delta)
{
    return wkNSReboundDeltaForElasticDelta(delta);
}

static float scrollWheelMultiplier()
{
    static float multiplier = -1;
    if (multiplier < 0) {
        multiplier = [[NSUserDefaults standardUserDefaults] floatForKey:@"NSScrollWheelMultiplier"];
        if (multiplier <= 0)
            multiplier = 1;
    }
    return multiplier;
}

ScrollController::ScrollController(ScrollControllerClient* client)
    : m_client(client)
    , m_inScrollGesture(false)
    , m_momentumScrollInProgress(false)
    , m_ignoreMomentumScrolls(false)
    , m_lastMomentumScrollTimestamp(0)
    , m_startTime(0)
    , m_snapRubberbandTimerIsActive(false)
{
}

bool ScrollController::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
{
    if (wheelEvent.phase() == PlatformWheelEventPhaseBegan) {
        // First, check if we should rubber-band at all.
        if (m_client->pinnedInDirection(FloatSize(-wheelEvent.deltaX(), 0))
            && !shouldRubberBandInHorizontalDirection(wheelEvent))
            return false;

        m_inScrollGesture = true;
        m_momentumScrollInProgress = false;
        m_ignoreMomentumScrolls = false;
        m_lastMomentumScrollTimestamp = 0;
        m_momentumVelocity = FloatSize();

        IntSize stretchAmount = m_client->stretchAmount();
        m_stretchScrollForce.setWidth(reboundDeltaForElasticDelta(stretchAmount.width()));
        m_stretchScrollForce.setHeight(reboundDeltaForElasticDelta(stretchAmount.height()));
        m_overflowScrollDelta = FloatSize();

        stopSnapRubberbandTimer();

        return true;
    }

    if (wheelEvent.phase() == PlatformWheelEventPhaseEnded) {
        snapRubberBand();
        return true;
    }

    bool isMomentumScrollEvent = (wheelEvent.momentumPhase() != PlatformWheelEventPhaseNone);
    if (m_ignoreMomentumScrolls && (isMomentumScrollEvent || m_snapRubberbandTimerIsActive)) {
        if (wheelEvent.momentumPhase() == PlatformWheelEventPhaseEnded) {
            m_ignoreMomentumScrolls = false;
            return true;
        }
        return false;
    }

    float deltaX = m_overflowScrollDelta.width();
    float deltaY = m_overflowScrollDelta.height();

    // Reset overflow values because we may decide to remove delta at various points and put it into overflow.
    m_overflowScrollDelta = FloatSize();

    IntSize stretchAmount = m_client->stretchAmount();
    bool isVerticallyStretched = stretchAmount.height();
    bool isHorizontallyStretched = stretchAmount.width();

    float eventCoalescedDeltaX;
    float eventCoalescedDeltaY;

    if (isVerticallyStretched || isHorizontallyStretched) {
        eventCoalescedDeltaX = -wheelEvent.unacceleratedScrollingDeltaX();
        eventCoalescedDeltaY = -wheelEvent.unacceleratedScrollingDeltaY();
    } else {
        eventCoalescedDeltaX = -wheelEvent.deltaX();
        eventCoalescedDeltaY = -wheelEvent.deltaY();
    }

    deltaX += eventCoalescedDeltaX;
    deltaY += eventCoalescedDeltaY;

    // Slightly prefer scrolling vertically by applying the = case to deltaY
    if (fabsf(deltaY) >= fabsf(deltaX))
        deltaX = 0;
    else
        deltaY = 0;

    bool shouldStretch = false;

    PlatformWheelEventPhase momentumPhase = wheelEvent.momentumPhase();

    // If we are starting momentum scrolling then do some setup.
    if (!m_momentumScrollInProgress && (momentumPhase == PlatformWheelEventPhaseBegan || momentumPhase == PlatformWheelEventPhaseChanged))
        m_momentumScrollInProgress = true;

    CFTimeInterval timeDelta = wheelEvent.timestamp() - m_lastMomentumScrollTimestamp;
    if (m_inScrollGesture || m_momentumScrollInProgress) {
        if (m_lastMomentumScrollTimestamp && timeDelta > 0 && timeDelta < scrollVelocityZeroingTimeout) {
            m_momentumVelocity.setWidth(eventCoalescedDeltaX / (float)timeDelta);
            m_momentumVelocity.setHeight(eventCoalescedDeltaY / (float)timeDelta);
            m_lastMomentumScrollTimestamp = wheelEvent.timestamp();
        } else {
            m_lastMomentumScrollTimestamp = wheelEvent.timestamp();
            m_momentumVelocity = FloatSize();
        }

        if (isVerticallyStretched) {
            if (!isHorizontallyStretched && m_client->pinnedInDirection(FloatSize(deltaX, 0))) {
                // Stretching only in the vertical.
                if (deltaY && (fabsf(deltaX / deltaY) < rubberbandDirectionLockStretchRatio))
                    deltaX = 0;
                else if (fabsf(deltaX) < rubberbandMinimumRequiredDeltaBeforeStretch) {
                    m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
                    deltaX = 0;
                } else
                    m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
            }
        } else if (isHorizontallyStretched) {
            // Stretching only in the horizontal.
            if (m_client->pinnedInDirection(FloatSize(0, deltaY))) {
                if (deltaX && (fabsf(deltaY / deltaX) < rubberbandDirectionLockStretchRatio))
                    deltaY = 0;
                else if (fabsf(deltaY) < rubberbandMinimumRequiredDeltaBeforeStretch) {
                    m_overflowScrollDelta.setHeight(m_overflowScrollDelta.height() + deltaY);
                    deltaY = 0;
                } else
                    m_overflowScrollDelta.setHeight(m_overflowScrollDelta.height() + deltaY);
            }
        } else {
            // Not stretching at all yet.
            if (m_client->pinnedInDirection(FloatSize(deltaX, deltaY))) {
                if (fabsf(deltaY) >= fabsf(deltaX)) {
                    if (fabsf(deltaX) < rubberbandMinimumRequiredDeltaBeforeStretch) {
                        m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
                        deltaX = 0;
                    } else
                        m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
                }
                shouldStretch = true;
            }
        }
    }

    if (deltaX || deltaY) {
        if (!(shouldStretch || isVerticallyStretched || isHorizontallyStretched)) {
            if (deltaY) {
                deltaY *= scrollWheelMultiplier();
                m_client->immediateScrollBy(FloatSize(0, deltaY));
            }
            if (deltaX) {
                deltaX *= scrollWheelMultiplier();
                m_client->immediateScrollBy(FloatSize(deltaX, 0));
            }
        } else {
            if (!m_client->allowsHorizontalStretching(wheelEvent)) {
                deltaX = 0;
                eventCoalescedDeltaX = 0;
            } else if (deltaX && !isHorizontallyStretched && !m_client->pinnedInDirection(FloatSize(deltaX, 0))) {
                deltaX *= scrollWheelMultiplier();

                m_client->immediateScrollByWithoutContentEdgeConstraints(FloatSize(deltaX, 0));
                deltaX = 0;
            }

            if (!m_client->allowsVerticalStretching(wheelEvent)) {
                deltaY = 0;
                eventCoalescedDeltaY = 0;
            } else if (deltaY && !isVerticallyStretched && !m_client->pinnedInDirection(FloatSize(0, deltaY))) {
                deltaY *= scrollWheelMultiplier();

                m_client->immediateScrollByWithoutContentEdgeConstraints(FloatSize(0, deltaY));
                deltaY = 0;
            }

            IntSize stretchAmount = m_client->stretchAmount();

            if (m_momentumScrollInProgress) {
                if ((m_client->pinnedInDirection(FloatSize(eventCoalescedDeltaX, eventCoalescedDeltaY)) || (fabsf(eventCoalescedDeltaX) + fabsf(eventCoalescedDeltaY) <= 0)) && m_lastMomentumScrollTimestamp) {
                    m_ignoreMomentumScrolls = true;
                    m_momentumScrollInProgress = false;
                    snapRubberBand();
                }
            }

            m_stretchScrollForce.setWidth(m_stretchScrollForce.width() + deltaX);
            m_stretchScrollForce.setHeight(m_stretchScrollForce.height() + deltaY);

            FloatSize dampedDelta(ceilf(elasticDeltaForReboundDelta(m_stretchScrollForce.width())), ceilf(elasticDeltaForReboundDelta(m_stretchScrollForce.height())));

            m_client->immediateScrollByWithoutContentEdgeConstraints(dampedDelta - stretchAmount);
        }
    }

    if (m_momentumScrollInProgress && momentumPhase == PlatformWheelEventPhaseEnded) {
        m_momentumScrollInProgress = false;
        m_ignoreMomentumScrolls = false;
        m_lastMomentumScrollTimestamp = 0;
    }

    return true;
}

static inline float roundTowardZero(float num)
{
    return num > 0 ? ceilf(num - 0.5f) : floorf(num + 0.5f);
}

static inline float roundToDevicePixelTowardZero(float num)
{
    float roundedNum = roundf(num);
    if (fabs(num - roundedNum) < 0.125)
        num = roundedNum;

    return roundTowardZero(num);
}

void ScrollController::snapRubberBandTimerFired()
{
    if (!m_momentumScrollInProgress || m_ignoreMomentumScrolls) {
        CFTimeInterval timeDelta = [NSDate timeIntervalSinceReferenceDate] - m_startTime;

        if (m_startStretch == FloatSize()) {
            m_startStretch = m_client->stretchAmount();
            if (m_startStretch == FloatSize()) {
                stopSnapRubberbandTimer();

                m_stretchScrollForce = FloatSize();
                m_startTime = 0;
                m_startStretch = FloatSize();
                m_origOrigin = FloatPoint();
                m_origVelocity = FloatSize();
                return;
            }

            m_origOrigin = m_client->absoluteScrollPosition() - m_startStretch;
            m_origVelocity = m_momentumVelocity;

            // Just like normal scrolling, prefer vertical rubberbanding
            if (fabsf(m_origVelocity.height()) >= fabsf(m_origVelocity.width()))
                m_origVelocity.setWidth(0);

            // Don't rubber-band horizontally if it's not possible to scroll horizontally
            if (!m_client->canScrollHorizontally())
                m_origVelocity.setWidth(0);

            // Don't rubber-band vertically if it's not possible to scroll vertically
            if (!m_client->canScrollVertically())
                m_origVelocity.setHeight(0);
        }

        FloatPoint delta(roundToDevicePixelTowardZero(elasticDeltaForTimeDelta(m_startStretch.width(), -m_origVelocity.width(), (float)timeDelta)),
            roundToDevicePixelTowardZero(elasticDeltaForTimeDelta(m_startStretch.height(), -m_origVelocity.height(), (float)timeDelta)));

        if (fabs(delta.x()) >= 1 || fabs(delta.y()) >= 1) {
            m_client->immediateScrollByWithoutContentEdgeConstraints(FloatSize(delta.x(), delta.y()) - m_client->stretchAmount());

            FloatSize newStretch = m_client->stretchAmount();

            m_stretchScrollForce.setWidth(reboundDeltaForElasticDelta(newStretch.width()));
            m_stretchScrollForce.setHeight(reboundDeltaForElasticDelta(newStretch.height()));
        } else {
            m_client->adjustScrollPositionToBoundsIfNecessary();

            stopSnapRubberbandTimer();
            m_stretchScrollForce = FloatSize();
            m_startTime = 0;
            m_startStretch = FloatSize();
            m_origOrigin = FloatPoint();
            m_origVelocity = FloatSize();
        }
    } else {
        m_startTime = [NSDate timeIntervalSinceReferenceDate];
        m_startStretch = FloatSize();
    }
}

bool ScrollController::isRubberBandInProgress() const
{
    if (!m_inScrollGesture && !m_momentumScrollInProgress && !m_snapRubberbandTimerIsActive)
        return false;

    return !m_client->stretchAmount().isZero();
}

void ScrollController::stopSnapRubberbandTimer()
{
    m_client->stopSnapRubberbandTimer();
    m_snapRubberbandTimerIsActive = false;
}

void ScrollController::snapRubberBand()
{
    CFTimeInterval timeDelta = systemUptime() - m_lastMomentumScrollTimestamp;
    if (m_lastMomentumScrollTimestamp && timeDelta >= scrollVelocityZeroingTimeout)
        m_momentumVelocity = FloatSize();

    m_inScrollGesture = false;

    if (m_snapRubberbandTimerIsActive)
        return;

    m_startTime = [NSDate timeIntervalSinceReferenceDate];
    m_startStretch = FloatSize();
    m_origOrigin = FloatPoint();
    m_origVelocity = FloatSize();

    m_client->startSnapRubberbandTimer();
    m_snapRubberbandTimerIsActive = true;
}

bool ScrollController::shouldRubberBandInHorizontalDirection(const PlatformWheelEvent& wheelEvent)
{
    if (wheelEvent.deltaX() > 0)
        return m_client->shouldRubberBandInDirection(ScrollLeft);
    if (wheelEvent.deltaX() < 0)
        return m_client->shouldRubberBandInDirection(ScrollRight);

    return true;
}

} // namespace WebCore

#endif // ENABLE(RUBBER_BANDING)

Return to Bug 142205

Lines 643-648 ScrollAnimatorMac::ScrollAnimatorMac(ScrollableArea& scrollableArea) a/Source/WebCore/platform/mac/ScrollAnimatorMac.mm_sec1
- a/Source/WebCore/platform/mac/ScrollAnimatorMac.mm +19 lines
643	: ScrollAnimator(scrollableArea)	643	: ScrollAnimator(scrollableArea)
644	, m_initialScrollbarPaintTimer(*this, &ScrollAnimatorMac::initialScrollbarPaintTimerFired)	644	, m_initialScrollbarPaintTimer(*this, &ScrollAnimatorMac::initialScrollbarPaintTimerFired)
645	, m_sendContentAreaScrolledTimer(*this, &ScrollAnimatorMac::sendContentAreaScrolledTimerFired)	645	, m_sendContentAreaScrolledTimer(*this, &ScrollAnimatorMac::sendContentAreaScrolledTimerFired)
		646	#if ENABLE(RUBBER_BANDING)
		647	, m_scrollController(this)
		648	, m_snapRubberBandTimer(*this, &ScrollAnimatorMac::snapRubberBandTimerFired)
		649	#endif
646	, m_haveScrolledSincePageLoad(false)	650	, m_haveScrolledSincePageLoad(false)
647	, m_needsScrollerStyleUpdate(false)	651	, m_needsScrollerStyleUpdate(false)
648	{	652	{
Lines 1266-1271 void ScrollAnimatorMac::immediateScrollBy(const FloatSize& delta) a/Source/WebCore/platform/mac/ScrollAnimatorMac.mm_sec2
1266	m_currentPosY = newPos.y();	1270	m_currentPosY = newPos.y();
1267	notifyPositionChanged(adjustedDelta);	1271	notifyPositionChanged(adjustedDelta);
1268	}	1272	}
		1273
		1274	void ScrollAnimatorMac::startSnapRubberbandTimer()
		1275	{
		1276	m_snapRubberBandTimer.startRepeating(1.0 / 60.0);
		1277	}
		1278
		1279	void ScrollAnimatorMac::stopSnapRubberbandTimer()
		1280	{
		1281	m_snapRubberBandTimer.stop();
		1282	}
		1283
		1284	void ScrollAnimatorMac::snapRubberBandTimerFired()
		1285	{
		1286	m_scrollController.snapRubberBandTimerFired();
		1287	}
1269	#endif	1288	#endif
1270		1289
1271	void ScrollAnimatorMac::updateScrollerStyle()	1290	void ScrollAnimatorMac::updateScrollerStyle()

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +15 lines
		1	2015-03-02 Commit Queue <commit-queue@webkit.org>
		2
		3	Unreviewed, rolling out r180902.
		4	https://bugs.webkit.org/show_bug.cgi?id=142205
		5
		6	It broke scrolling in some cases. See bug 142202 for details.
		7	(Requested by bdash on #webkit).
		8
		9	Reverted changeset:
		10
		11	"Move scroll animating functions from ScrollAnimator to
		12	ScrollController"
		13	https://bugs.webkit.org/show_bug.cgi?id=142102
		14	http://trac.webkit.org/changeset/180902
		15
1	2015-03-02 Yoav Weiss <yoav@yoav.ws>	16	2015-03-02 Yoav Weiss <yoav@yoav.ws>
2		17
3	Add a microtask abstraction	18	Add a microtask abstraction

Lines 786-791 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj -8 / +8 lines
786	1A927FD31416A15B003A83C8 /* npruntime.h in Headers / = {isa = PBXBuildFile; fileRef = 1A927FD01416A15B003A83C8 / npruntime.h */; settings = {ATTRIBUTES = (Private, ); }; };	786	1A927FD31416A15B003A83C8 /* npruntime.h in Headers / = {isa = PBXBuildFile; fileRef = 1A927FD01416A15B003A83C8 / npruntime.h */; settings = {ATTRIBUTES = (Private, ); }; };
787	1A927FD41416A15B003A83C8 /* nptypes.h in Headers / = {isa = PBXBuildFile; fileRef = 1A927FD11416A15B003A83C8 / nptypes.h */; settings = {ATTRIBUTES = (Private, ); }; };	787	1A927FD41416A15B003A83C8 /* nptypes.h in Headers / = {isa = PBXBuildFile; fileRef = 1A927FD11416A15B003A83C8 / nptypes.h */; settings = {ATTRIBUTES = (Private, ); }; };
788	1A98956B0AA78F80005EF5EF /* URLCF.cpp in Sources / = {isa = PBXBuildFile; fileRef = 1A98956A0AA78F80005EF5EF / URLCF.cpp */; };	788	1A98956B0AA78F80005EF5EF /* URLCF.cpp in Sources / = {isa = PBXBuildFile; fileRef = 1A98956A0AA78F80005EF5EF / URLCF.cpp */; };
		789	1AA84F04143BA7BD0051D153 /* ScrollController.mm in Sources / = {isa = PBXBuildFile; fileRef = 1AA84F02143BA7BD0051D153 / ScrollController.mm */; };
		790	1AA84F05143BA7BD0051D153 /* ScrollController.h in Headers / = {isa = PBXBuildFile; fileRef = 1AA84F03143BA7BD0051D153 / ScrollController.h */; settings = {ATTRIBUTES = (Private, ); }; };
789	1AA8799011CBE846003C664F /* PluginStrategy.h in Headers / = {isa = PBXBuildFile; fileRef = 1AA8798F11CBE846003C664F / PluginStrategy.h */; settings = {ATTRIBUTES = (Private, ); }; };	791	1AA8799011CBE846003C664F /* PluginStrategy.h in Headers / = {isa = PBXBuildFile; fileRef = 1AA8798F11CBE846003C664F / PluginStrategy.h */; settings = {ATTRIBUTES = (Private, ); }; };
790	1AAADDA314DB409F00AF64B3 /* ScrollingTree.cpp in Sources / = {isa = PBXBuildFile; fileRef = 1AAADDA114DB409F00AF64B3 / ScrollingTree.cpp */; };	792	1AAADDA314DB409F00AF64B3 /* ScrollingTree.cpp in Sources / = {isa = PBXBuildFile; fileRef = 1AAADDA114DB409F00AF64B3 / ScrollingTree.cpp */; };
791	1AAADDA414DB409F00AF64B3 /* ScrollingTree.h in Headers / = {isa = PBXBuildFile; fileRef = 1AAADDA214DB409F00AF64B3 / ScrollingTree.h */; settings = {ATTRIBUTES = (Private, ); }; };	793	1AAADDA414DB409F00AF64B3 /* ScrollingTree.h in Headers / = {isa = PBXBuildFile; fileRef = 1AAADDA214DB409F00AF64B3 / ScrollingTree.h */; settings = {ATTRIBUTES = (Private, ); }; };
Lines 2444-2451 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
2444	7A74ECBD101839DA00BF939E /* JSInspectorFrontendHostCustom.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7A74ECBC101839DA00BF939E / JSInspectorFrontendHostCustom.cpp */; };	2446	7A74ECBD101839DA00BF939E /* JSInspectorFrontendHostCustom.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7A74ECBC101839DA00BF939E / JSInspectorFrontendHostCustom.cpp */; };
2445	7A93868518DCC14500B8263D /* VTTScanner.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7A93868218DCC14500B8263D / VTTScanner.cpp */; };	2447	7A93868518DCC14500B8263D /* VTTScanner.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7A93868218DCC14500B8263D / VTTScanner.cpp */; };
2446	7A93868618DCC14500B8263D /* VTTScanner.h in Headers / = {isa = PBXBuildFile; fileRef = 7A93868318DCC14500B8263D / VTTScanner.h */; };	2448	7A93868618DCC14500B8263D /* VTTScanner.h in Headers / = {isa = PBXBuildFile; fileRef = 7A93868318DCC14500B8263D / VTTScanner.h */; };
2447	7A9ADFF31AA1163800D2733C /* ScrollController.h in Headers / = {isa = PBXBuildFile; fileRef = 7AFFA4111AA1039D00F0125B / ScrollController.h */; settings = {ATTRIBUTES = (Private, ); }; };
2448	7A9ADFF41AA1163B00D2733C /* ScrollController.mm in Sources / = {isa = PBXBuildFile; fileRef = 7AFFA4121AA1039D00F0125B / ScrollController.mm */; };
2449	7AA3A699194A64E7001CBD24 /* TileController.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7AA3A695194A64E7001CBD24 / TileController.cpp */; };	2449	7AA3A699194A64E7001CBD24 /* TileController.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7AA3A695194A64E7001CBD24 / TileController.cpp */; };
2450	7AA3A69A194A64E7001CBD24 /* TileController.h in Headers / = {isa = PBXBuildFile; fileRef = 7AA3A696194A64E7001CBD24 / TileController.h */; settings = {ATTRIBUTES = (Private, ); }; };	2450	7AA3A69A194A64E7001CBD24 /* TileController.h in Headers / = {isa = PBXBuildFile; fileRef = 7AA3A696194A64E7001CBD24 / TileController.h */; settings = {ATTRIBUTES = (Private, ); }; };
2451	7AA3A69B194A64E7001CBD24 /* TileGrid.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7AA3A697194A64E7001CBD24 / TileGrid.cpp */; };	2451	7AA3A69B194A64E7001CBD24 /* TileGrid.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7AA3A697194A64E7001CBD24 / TileGrid.cpp */; };
Lines 7813-7818 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
7813	1A927FD01416A15B003A83C8 /* npruntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = npruntime.h; sourceTree = "<group>"; };	7813	1A927FD01416A15B003A83C8 /* npruntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = npruntime.h; sourceTree = "<group>"; };
7814	1A927FD11416A15B003A83C8 /* nptypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nptypes.h; sourceTree = "<group>"; };	7814	1A927FD11416A15B003A83C8 /* nptypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nptypes.h; sourceTree = "<group>"; };
7815	1A98956A0AA78F80005EF5EF /* URLCF.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = URLCF.cpp; sourceTree = "<group>"; };	7815	1A98956A0AA78F80005EF5EF /* URLCF.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = URLCF.cpp; sourceTree = "<group>"; };
		7816	1AA84F02143BA7BD0051D153 /* ScrollController.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ScrollController.mm; sourceTree = "<group>"; };
		7817	1AA84F03143BA7BD0051D153 /* ScrollController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollController.h; sourceTree = "<group>"; };
7816	1AA8798F11CBE846003C664F /* PluginStrategy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PluginStrategy.h; sourceTree = "<group>"; };	7818	1AA8798F11CBE846003C664F /* PluginStrategy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PluginStrategy.h; sourceTree = "<group>"; };
7817	1AAADDA114DB409F00AF64B3 /* ScrollingTree.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ScrollingTree.cpp; sourceTree = "<group>"; };	7819	1AAADDA114DB409F00AF64B3 /* ScrollingTree.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ScrollingTree.cpp; sourceTree = "<group>"; };
7818	1AAADDA214DB409F00AF64B3 /* ScrollingTree.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollingTree.h; sourceTree = "<group>"; };	7820	1AAADDA214DB409F00AF64B3 /* ScrollingTree.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollingTree.h; sourceTree = "<group>"; };
Lines 9670-9677 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
9670	7AF9B20918CFB5F200C64BEF /* JSVTTRegion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSVTTRegion.h; sourceTree = "<group>"; };	9672	7AF9B20918CFB5F200C64BEF /* JSVTTRegion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSVTTRegion.h; sourceTree = "<group>"; };
9671	7AF9B20A18CFB5F300C64BEF /* JSVTTRegionList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSVTTRegionList.cpp; sourceTree = "<group>"; };	9673	7AF9B20A18CFB5F300C64BEF /* JSVTTRegionList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSVTTRegionList.cpp; sourceTree = "<group>"; };
9672	7AF9B20B18CFB5F300C64BEF /* JSVTTRegionList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSVTTRegionList.h; sourceTree = "<group>"; };	9674	7AF9B20B18CFB5F300C64BEF /* JSVTTRegionList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSVTTRegionList.h; sourceTree = "<group>"; };
9673	7AFFA4111AA1039D00F0125B /* ScrollController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollController.h; sourceTree = "<group>"; };
9674	7AFFA4121AA1039D00F0125B /* ScrollController.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ScrollController.mm; sourceTree = "<group>"; };
9675	7C2BDD3B17C7F98B0038FF15 /* JSDOMGlobalObjectTask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMGlobalObjectTask.cpp; sourceTree = "<group>"; };	9675	7C2BDD3B17C7F98B0038FF15 /* JSDOMGlobalObjectTask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMGlobalObjectTask.cpp; sourceTree = "<group>"; };
9676	7C2BDD3C17C7F98B0038FF15 /* JSDOMGlobalObjectTask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDOMGlobalObjectTask.h; sourceTree = "<group>"; };	9676	7C2BDD3C17C7F98B0038FF15 /* JSDOMGlobalObjectTask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDOMGlobalObjectTask.h; sourceTree = "<group>"; };
9677	7C3B796F1908757B00B47A2D /* UserMessageHandler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = UserMessageHandler.cpp; sourceTree = "<group>"; };	9677	7C3B796F1908757B00B47A2D /* UserMessageHandler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = UserMessageHandler.cpp; sourceTree = "<group>"; };
Lines 16597-16602 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec5
16597	BC51156D12B1749C00C96754 /* ScrollAnimatorMac.mm */,	16597	BC51156D12B1749C00C96754 /* ScrollAnimatorMac.mm */,
16598	BC8B853C0E7C7F1100AB6984 /* ScrollbarThemeMac.h */,	16598	BC8B853C0E7C7F1100AB6984 /* ScrollbarThemeMac.h */,
16599	BCEF869E0E844E9D00A85CD5 /* ScrollbarThemeMac.mm */,	16599	BCEF869E0E844E9D00A85CD5 /* ScrollbarThemeMac.mm */,
		16600	1AA84F03143BA7BD0051D153 /* ScrollController.h */,
		16601	1AA84F02143BA7BD0051D153 /* ScrollController.mm */,
16600	9353676A09AED88B00D35CD6 /* ScrollViewMac.mm */,	16602	9353676A09AED88B00D35CD6 /* ScrollViewMac.mm */,
16601	077AF14118F4B1BB0001ED61 /* SerializedPlatformRepresentationMac.h */,	16603	077AF14118F4B1BB0001ED61 /* SerializedPlatformRepresentationMac.h */,
16602	077AF14218F4B1BB0001ED61 /* SerializedPlatformRepresentationMac.mm */,	16604	077AF14218F4B1BB0001ED61 /* SerializedPlatformRepresentationMac.mm */,
Lines 18706-18713 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec6
18706	1A0409F21A43675C009E47F3 /* MachSendRight.cpp */,	18708	1A0409F21A43675C009E47F3 /* MachSendRight.cpp */,
18707	1A0409DB1A4360B5009E47F3 /* MachSendRight.h */,	18709	1A0409DB1A4360B5009E47F3 /* MachSendRight.h */,
18708	ADB6B29718FB90240081963E /* MemoryPressureHandlerCocoa.mm */,	18710	ADB6B29718FB90240081963E /* MemoryPressureHandlerCocoa.mm */,
18709	7AFFA4111AA1039D00F0125B /* ScrollController.h */,
18710	7AFFA4121AA1039D00F0125B /* ScrollController.mm */,
18711	5D5975B119635F1100D00878 /* SystemVersion.h */,	18711	5D5975B119635F1100D00878 /* SystemVersion.h */,
18712	5D5975B219635F1100D00878 /* SystemVersion.mm */,	18712	5D5975B219635F1100D00878 /* SystemVersion.mm */,
18713	7CC564B918BAC720001B9652 /* TelephoneNumberDetectorCocoa.cpp */,	18713	7CC564B918BAC720001B9652 /* TelephoneNumberDetectorCocoa.cpp */,
Lines 24661-24667 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec7
24661	A8EA7CB50A192B9C00A8EF5F /* HTMLParagraphElement.h in Headers */,	24661	A8EA7CB50A192B9C00A8EF5F /* HTMLParagraphElement.h in Headers */,
24662	A871D4580A127CBC00B12A68 /* HTMLParamElement.h in Headers */,	24662	A871D4580A127CBC00B12A68 /* HTMLParamElement.h in Headers */,
24663	93E2A307123E9DC0009FE12A /* HTMLParserIdioms.h in Headers */,	24663	93E2A307123E9DC0009FE12A /* HTMLParserIdioms.h in Headers */,
24664	7A9ADFF31AA1163800D2733C /* ScrollController.h in Headers */,
24665	973F418A169B95FF0006BF60 /* HTMLParserOptions.h in Headers */,	24664	973F418A169B95FF0006BF60 /* HTMLParserOptions.h in Headers */,
24666	977B3871122883E900B81FF8 /* HTMLParserScheduler.h in Headers */,	24665	977B3871122883E900B81FF8 /* HTMLParserScheduler.h in Headers */,
24667	A871D4560A127CBC00B12A68 /* HTMLPlugInElement.h in Headers */,	24666	A871D4560A127CBC00B12A68 /* HTMLPlugInElement.h in Headers */,
Lines 26116-26121 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec8
26116	BC8B853E0E7C7F1100AB6984 /* ScrollbarThemeMac.h in Headers */,	26115	BC8B853E0E7C7F1100AB6984 /* ScrollbarThemeMac.h in Headers */,
26117	0FE71406142170B800DB33BA /* ScrollbarThemeMock.h in Headers */,	26116	0FE71406142170B800DB33BA /* ScrollbarThemeMock.h in Headers */,
26118	5D925B680F64D4DD00B847F0 /* ScrollBehavior.h in Headers */,	26117	5D925B680F64D4DD00B847F0 /* ScrollBehavior.h in Headers */,
		26118	1AA84F05143BA7BD0051D153 /* ScrollController.h in Headers */,
26119	0F605AED15F94848004DF0C0 /* ScrollingConstraints.h in Headers */,	26119	0F605AED15F94848004DF0C0 /* ScrollingConstraints.h in Headers */,
26120	1AF62EE814DA22A70041556C /* ScrollingCoordinator.h in Headers */,	26120	1AF62EE814DA22A70041556C /* ScrollingCoordinator.h in Headers */,
26121	0FC4E40D187F82E10045882C /* ScrollingCoordinatorIOS.h in Headers */,	26121	0FC4E40D187F82E10045882C /* ScrollingCoordinatorIOS.h in Headers */,
Lines 27511-27517 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec9
27511	E19AC3F41824DC7900349426 /* CryptoAlgorithmSHA512.cpp in Sources */,	27511	E19AC3F41824DC7900349426 /* CryptoAlgorithmSHA512.cpp in Sources */,
27512	E1FE13641834351100892F13 /* CryptoDigestMac.cpp in Sources */,	27512	E1FE13641834351100892F13 /* CryptoDigestMac.cpp in Sources */,
27513	E157A8E418173A3A009F821D /* CryptoKey.cpp in Sources */,	27513	E157A8E418173A3A009F821D /* CryptoKey.cpp in Sources */,
27514	7A9ADFF41AA1163B00D2733C /* ScrollController.mm in Sources */,
27515	E125F84D1824289D00D84CD9 /* CryptoKeyAES.cpp in Sources */,	27514	E125F84D1824289D00D84CD9 /* CryptoKeyAES.cpp in Sources */,
27516	E125F863182C303A00D84CD9 /* CryptoKeyDataOctetSequence.cpp in Sources */,	27515	E125F863182C303A00D84CD9 /* CryptoKeyDataOctetSequence.cpp in Sources */,
27517	E1C266DE18319F31003F8B33 /* CryptoKeyDataRSAComponents.cpp in Sources */,	27516	E1C266DE18319F31003F8B33 /* CryptoKeyDataRSAComponents.cpp in Sources */,
Lines 29524-29529 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec10
29524	BCEF869F0E844E9D00A85CD5 /* ScrollbarThemeMac.mm in Sources */,	29523	BCEF869F0E844E9D00A85CD5 /* ScrollbarThemeMac.mm in Sources */,
29525	0FE71405142170B800DB33BA /* ScrollbarThemeMock.cpp in Sources */,	29524	0FE71405142170B800DB33BA /* ScrollbarThemeMock.cpp in Sources */,
29526	5D925B670F64D4DD00B847F0 /* ScrollBehavior.cpp in Sources */,	29525	5D925B670F64D4DD00B847F0 /* ScrollBehavior.cpp in Sources */,
		29526	1AA84F04143BA7BD0051D153 /* ScrollController.mm in Sources */,
29527	0F605AEC15F94848004DF0C0 /* ScrollingConstraints.cpp in Sources */,	29527	0F605AEC15F94848004DF0C0 /* ScrollingConstraints.cpp in Sources */,
29528	1AF62EE714DA22A70041556C /* ScrollingCoordinator.cpp in Sources */,	29528	1AF62EE714DA22A70041556C /* ScrollingCoordinator.cpp in Sources */,
29529	0FC4E40E187F82E10045882C /* ScrollingCoordinatorIOS.mm in Sources */,	29529	0FC4E40E187F82E10045882C /* ScrollingCoordinatorIOS.mm in Sources */,

Lines 961-972 bool EventHandler::platformCompleteWheelEvent(const PlatformWheelEvent& wheelEve a/Source/WebCore/page/mac/EventHandlerMac.mm_sec1
- a/Source/WebCore/page/mac/EventHandlerMac.mm -6 lines
961		961
962	bool didHandleEvent = view ? view->wheelEvent(wheelEvent) : false;	962	bool didHandleEvent = view ? view->wheelEvent(wheelEvent) : false;
963	m_isHandlingWheelEvent = false;	963	m_isHandlingWheelEvent = false;
964
965	#if ENABLE(CSS_SCROLL_SNAP)
966	if (scrollableArea)
967	platformNotifySnapIfNecessary(wheelEvent, *scrollableArea);
968	#endif
969
970	return didHandleEvent;	964	return didHandleEvent;
971	}	965	}
972		966

Lines 61-66 private: a/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h_sec1
- a/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h -5 / +3 lines
61	virtual IntPoint absoluteScrollPosition() override;	61	virtual IntPoint absoluteScrollPosition() override;
62	virtual void immediateScrollBy(const FloatSize&) override;	62	virtual void immediateScrollBy(const FloatSize&) override;
63	virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) override;	63	virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) override;
		64	virtual void startSnapRubberbandTimer() override;
		65	virtual void stopSnapRubberbandTimer() override;
64	virtual void adjustScrollPositionToBoundsIfNecessary() override;	66	virtual void adjustScrollPositionToBoundsIfNecessary() override;
65		67
66	virtual FloatPoint scrollPosition() const override;	68	virtual FloatPoint scrollPosition() const override;
Lines 78-91 private: a/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h_sec2
78		80
79	bool isAlreadyPinnedInDirectionOfGesture(const PlatformWheelEvent&, ScrollEventAxis);	81	bool isAlreadyPinnedInDirectionOfGesture(const PlatformWheelEvent&, ScrollEventAxis);
80		82
81	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
82	LayoutUnit scrollOffsetOnAxis(ScrollEventAxis) override;
83	void immediateScrollOnAxis(ScrollEventAxis, float delta) override;
84	#endif
85
86	void logExposedUnfilledArea();	83	void logExposedUnfilledArea();
87		84
88	ScrollController m_scrollController;	85	ScrollController m_scrollController;
		86	RetainPtr<CFRunLoopTimerRef> m_snapRubberbandTimer;
89		87
90	RetainPtr<CALayer> m_scrollLayer;	88	RetainPtr<CALayer> m_scrollLayer;
91	RetainPtr<CALayer> m_scrolledContentsLayer;	89	RetainPtr<CALayer> m_scrolledContentsLayer;

Lines 66-71 ScrollingTreeFrameScrollingNodeMac::ScrollingTreeFrameScrollingNodeMac(Scrolling a/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm_sec1
- a/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm -13 / +28 lines
66		66
67	ScrollingTreeFrameScrollingNodeMac::~ScrollingTreeFrameScrollingNodeMac()	67	ScrollingTreeFrameScrollingNodeMac::~ScrollingTreeFrameScrollingNodeMac()
68	{	68	{
		69	if (m_snapRubberbandTimer)
		70	CFRunLoopTimerInvalidate(m_snapRubberbandTimer.get());
69	}	71	}
70		72
71	void ScrollingTreeFrameScrollingNodeMac::updateBeforeChildren(const ScrollingStateNode& stateNode)	73	void ScrollingTreeFrameScrollingNodeMac::updateBeforeChildren(const ScrollingStateNode& stateNode)
Lines 294-299 void ScrollingTreeFrameScrollingNodeMac::immediateScrollByWithoutContentEdgeCons a/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm_sec2
294	scrollByWithoutContentEdgeConstraints(offset);	296	scrollByWithoutContentEdgeConstraints(offset);
295	}	297	}
296		298
		299	void ScrollingTreeFrameScrollingNodeMac::startSnapRubberbandTimer()
		300	{
		301	ASSERT(!m_snapRubberbandTimer);
		302
		303	CFTimeInterval timerInterval = 1.0 / 60.0;
		304
		305	m_snapRubberbandTimer = adoptCF(CFRunLoopTimerCreateWithHandler(kCFAllocatorDefault, CFAbsoluteTimeGetCurrent() + timerInterval, timerInterval, 0, 0, ^(CFRunLoopTimerRef) {
		306	m_scrollController.snapRubberBandTimerFired();
		307	}));
		308	CFRunLoopAddTimer(CFRunLoopGetCurrent(), m_snapRubberbandTimer.get(), kCFRunLoopDefaultMode);
		309	}
		310
		311	void ScrollingTreeFrameScrollingNodeMac::stopSnapRubberbandTimer()
		312	{
		313	if (!m_snapRubberbandTimer)
		314	return;
		315
		316	scrollingTree().setMainFrameIsRubberBanding(false);
		317
		318	// Since the rubberband timer has stopped, totalContentsSizeForRubberBand can be synchronized with totalContentsSize.
		319	setTotalContentsSizeForRubberBand(totalContentsSize());
		320
		321	CFRunLoopTimerInvalidate(m_snapRubberbandTimer.get());
		322	m_snapRubberbandTimer = nullptr;
		323	}
		324
297	void ScrollingTreeFrameScrollingNodeMac::adjustScrollPositionToBoundsIfNecessary()	325	void ScrollingTreeFrameScrollingNodeMac::adjustScrollPositionToBoundsIfNecessary()
298	{	326	{
299	FloatPoint currentScrollPosition = absoluteScrollPosition();	327	FloatPoint currentScrollPosition = absoluteScrollPosition();
Lines 512-530 void logWheelEventHandlerCountChanged(unsigned count) a/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm_sec3
512	WTFLogAlways("SCROLLING: Wheel event handler count changed. Time: %f Count: %u\n", WTF::monotonicallyIncreasingTime(), count);	540	WTFLogAlways("SCROLLING: Wheel event handler count changed. Time: %f Count: %u\n", WTF::monotonicallyIncreasingTime(), count);
513	}	541	}
514		542
515	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
516	LayoutUnit ScrollingTreeFrameScrollingNodeMac::scrollOffsetOnAxis(ScrollEventAxis)
517	{
518	// Temporary stub until http://webkit.org/b/141973.
519	return 0;
520	}
521
522	void ScrollingTreeFrameScrollingNodeMac::immediateScrollOnAxis(ScrollEventAxis, float)
523	{
524	// Temporary stub until http://webkit.org/b/141973.
525	}
526	#endif
527
528	} // namespace WebCore	543	} // namespace WebCore
529		544
530	#endif // ENABLE(ASYNC_SCROLLING) && PLATFORM(MAC)	545	#endif // ENABLE(ASYNC_SCROLLING) && PLATFORM(MAC)

Lines 49-57 std::unique_ptr<ScrollAnimator> ScrollAnimator::create(ScrollableArea& scrollabl a/Source/WebCore/platform/ScrollAnimator.cpp_sec1
- a/Source/WebCore/platform/ScrollAnimator.cpp -10 / +58 lines
49		49
50	ScrollAnimator::ScrollAnimator(ScrollableArea& scrollableArea)	50	ScrollAnimator::ScrollAnimator(ScrollableArea& scrollableArea)
51	: m_scrollableArea(scrollableArea)	51	: m_scrollableArea(scrollableArea)
52	#if (ENABLE(CSS_SCROLL_SNAP) \|\| ENABLE(RUBBER_BANDING)) && PLATFORM(MAC)
53	, m_scrollController(this)
54	#endif
55	, m_currentPosX(0)	52	, m_currentPosX(0)
56	, m_currentPosY(0)	53	, m_currentPosY(0)
57	{	54	{
Lines 84-99 void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset) a/Source/WebCore/platform/ScrollAnimator.cpp_sec2
84	}	81	}
85		82
86	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)	83	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
87	bool ScrollAnimator::processWheelEventForScrollSnap(const PlatformWheelEvent& wheelEvent)	84	void ScrollAnimator::processWheelEventForScrollSnap(const PlatformWheelEvent& wheelEvent)
88	{	85	{
89	return m_scrollController.processWheelEventForScrollSnap(wheelEvent);	86	if (m_verticalScrollSnapAnimator)
		87	m_verticalScrollSnapAnimator->handleWheelEvent(wheelEvent);
		88	if (m_horizontalScrollSnapAnimator)
		89	m_horizontalScrollSnapAnimator->handleWheelEvent(wheelEvent);
90	}	90	}
91	#endif	91	#endif
92		92
93	bool ScrollAnimator::handleWheelEvent(const PlatformWheelEvent& e)	93	bool ScrollAnimator::handleWheelEvent(const PlatformWheelEvent& e)
94	{	94	{
95	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)	95	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
96	m_scrollController.processWheelEventForScrollSnap(e);	96	if (m_verticalScrollSnapAnimator) {
		97	m_verticalScrollSnapAnimator->handleWheelEvent(e);
		98	if (m_verticalScrollSnapAnimator->shouldOverrideWheelEvent(e))
		99	return false;
		100	}
		101	if (m_horizontalScrollSnapAnimator) {
		102	m_horizontalScrollSnapAnimator->handleWheelEvent(e);
		103	if (m_horizontalScrollSnapAnimator->shouldOverrideWheelEvent(e))
		104	return false;
		105	}
97	#endif	106	#endif
98	#if PLATFORM(COCOA)	107	#if PLATFORM(COCOA)
99	// Events in the PlatformWheelEventPhaseMayBegin phase have no deltas, and therefore never passes through the scroll handling logic below.	108	// Events in the PlatformWheelEventPhaseMayBegin phase have no deltas, and therefore never passes through the scroll handling logic below.
Lines 174-188 void ScrollAnimator::notifyPositionChanged(const FloatSize& delta) a/Source/WebCore/platform/ScrollAnimator.cpp_sec3
174	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)	183	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
175	void ScrollAnimator::updateScrollAnimatorsAndTimers()	184	void ScrollAnimator::updateScrollAnimatorsAndTimers()
176	{	185	{
177	m_scrollController.updateScrollAnimatorsAndTimers(m_scrollableArea);	186	// FIXME: Currently, scroll snap animators are recreated even though the snap offsets alone can be updated.
		187	if (m_scrollableArea.horizontalSnapOffsets()) {
		188	m_horizontalScrollSnapAnimator = std::make_unique<AxisScrollSnapAnimator>(this, m_scrollableArea.horizontalSnapOffsets(), ScrollEventAxis::Horizontal);
		189	m_horizontalScrollSnapTimer = std::make_unique<Timer>(*this, &ScrollAnimator::horizontalScrollSnapTimerFired);
		190	} else if (m_horizontalScrollSnapAnimator) {
		191	m_horizontalScrollSnapAnimator = nullptr;
		192	m_horizontalScrollSnapTimer = nullptr;
		193	}
		194	if (m_scrollableArea.verticalSnapOffsets()) {
		195	m_verticalScrollSnapAnimator = std::make_unique<AxisScrollSnapAnimator>(this, m_scrollableArea.verticalSnapOffsets(), ScrollEventAxis::Vertical);
		196	m_verticalScrollSnapTimer = std::make_unique<Timer>(*this, &ScrollAnimator::verticalScrollSnapTimerFired);
		197	} else if (m_verticalScrollSnapAnimator) {
		198	m_verticalScrollSnapAnimator = nullptr;
		199	m_verticalScrollSnapTimer = nullptr;
		200	}
178	}	201	}
179		202
180	LayoutUnit ScrollAnimator::scrollOffsetOnAxis(ScrollEventAxis axis)	203	LayoutUnit ScrollAnimator::scrollOffsetInAxis(ScrollEventAxis axis)
181	{	204	{
182	return axis == ScrollEventAxis::Horizontal ? m_currentPosX : m_currentPosY;	205	FloatPoint currentPosition = this->currentPosition();
		206	return axis == ScrollEventAxis::Horizontal ? currentPosition.x() : currentPosition.y();
183	}	207	}
184		208
185	void ScrollAnimator::immediateScrollOnAxis(ScrollEventAxis axis, float delta)	209	void ScrollAnimator::immediateScrollInAxis(ScrollEventAxis axis, float delta)
186	{	210	{
187	FloatPoint currentPosition = this->currentPosition();	211	FloatPoint currentPosition = this->currentPosition();
188	if (axis == ScrollEventAxis::Horizontal)	212	if (axis == ScrollEventAxis::Horizontal)
Lines 190-195 void ScrollAnimator::immediateScrollOnAxis(ScrollEventAxis axis, float delta) a/Source/WebCore/platform/ScrollAnimator.cpp_sec4
190	else	214	else
191	scrollToOffsetWithoutAnimation(FloatPoint(currentPosition.x(), currentPosition.y() + delta));	215	scrollToOffsetWithoutAnimation(FloatPoint(currentPosition.x(), currentPosition.y() + delta));
192	}	216	}
		217
		218	void ScrollAnimator::startScrollSnapTimer(ScrollEventAxis axis)
		219	{
		220	Timer* scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer.get() : m_verticalScrollSnapTimer.get();
		221	if (!scrollSnapTimer->isActive())
		222	scrollSnapTimer->startRepeating(1.0 / 60.0);
		223	}
		224
		225	void ScrollAnimator::stopScrollSnapTimer(ScrollEventAxis axis)
		226	{
		227	Timer* scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer.get() : m_verticalScrollSnapTimer.get();
		228	if (scrollSnapTimer->isActive())
		229	scrollSnapTimer->stop();
		230	}
		231
		232	void ScrollAnimator::horizontalScrollSnapTimerFired()
		233	{
		234	m_horizontalScrollSnapAnimator->scrollSnapAnimationUpdate();
		235	}
		236
		237	void ScrollAnimator::verticalScrollSnapTimerFired()
		238	{
		239	m_verticalScrollSnapAnimator->scrollSnapAnimationUpdate();
		240	}
193	#endif	241	#endif
194		242
195	} // namespace WebCore	243	} // namespace WebCore

Lines 33-46 a/Source/WebCore/platform/ScrollAnimator.h_sec1
- a/Source/WebCore/platform/ScrollAnimator.h -12 / +23 lines
33	#define ScrollAnimator_h	33	#define ScrollAnimator_h
34		34
35	#include "FloatSize.h"	35	#include "FloatSize.h"
36	#include "LayoutUnit.h"
37	#include "PlatformWheelEvent.h"	36	#include "PlatformWheelEvent.h"
38	#include "ScrollTypes.h"	37	#include "ScrollTypes.h"
39	#include <wtf/FastMalloc.h>	38	#include <wtf/FastMalloc.h>
40	#include <wtf/Forward.h>	39	#include <wtf/Forward.h>
41		40
42	#if (ENABLE(RUBBER_BANDING) \|\| ENABLE(CSS_SCROLL_SNAP)) && PLATFORM(MAC)	41	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
43	#include "ScrollController.h"	42	#include "AxisScrollSnapAnimator.h"
		43	#include "Timer.h"
44	#endif	44	#endif
45		45
46	namespace WebCore {	46	namespace WebCore {
Lines 50-57 class PlatformTouchEvent; a/Source/WebCore/platform/ScrollAnimator.h_sec2
50	class ScrollableArea;	50	class ScrollableArea;
51	class Scrollbar;	51	class Scrollbar;
52		52
53	#if (ENABLE(CSS_SCROLL_SNAP) \|\| ENABLE(RUBBER_BANDING)) && PLATFORM(MAC)	53	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
54	class ScrollAnimator : private ScrollControllerClient {	54	class ScrollAnimator : public AxisScrollSnapAnimatorClient {
55	#else	55	#else
56	class ScrollAnimator {	56	class ScrollAnimator {
57	#endif	57	#endif
Lines 118-139 public: a/Source/WebCore/platform/ScrollAnimator.h_sec3
118	virtual bool isRubberBandInProgress() const { return false; }	118	virtual bool isRubberBandInProgress() const { return false; }
119		119
120	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)	120	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
121	bool processWheelEventForScrollSnap(const PlatformWheelEvent&);	121	void processWheelEventForScrollSnap(const PlatformWheelEvent&);
122
123	void updateScrollAnimatorsAndTimers();	122	void updateScrollAnimatorsAndTimers();
124	LayoutUnit scrollOffsetOnAxis(ScrollEventAxis) override;	123	virtual LayoutUnit scrollOffsetInAxis(ScrollEventAxis) override;
125	void immediateScrollOnAxis(ScrollEventAxis, float delta) override;	124	virtual void immediateScrollInAxis(ScrollEventAxis, float delta) override;
		125	virtual void startScrollSnapTimer(ScrollEventAxis) override;
		126	virtual void stopScrollSnapTimer(ScrollEventAxis) override;
126	#endif	127	#endif
127		128
128	protected:	129	protected:
129	virtual void notifyPositionChanged(const FloatSize& delta);	130	virtual void notifyPositionChanged(const FloatSize& delta);
130		131
131	ScrollableArea& m_scrollableArea;	132	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
132	#if (ENABLE(CSS_SCROLL_SNAP) \|\| ENABLE(RUBBER_BANDING)) && PLATFORM(MAC)	133	// Trivial wrappers around the actual update loop in AxisScrollSnapAnimator, since WebCore Timer requires a Timer argument.
133	ScrollController m_scrollController;	134	void horizontalScrollSnapTimerFired();
		135	void verticalScrollSnapTimerFired();
134	#endif	136	#endif
		137
		138	ScrollableArea& m_scrollableArea;
135	float m_currentPosX; // We avoid using a FloatPoint in order to reduce	139	float m_currentPosX; // We avoid using a FloatPoint in order to reduce
136	float m_currentPosY; // subclass code complexity.	140	float m_currentPosY; // subclass code complexity.
		141	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
		142	std::unique_ptr<AxisScrollSnapAnimator> m_horizontalScrollSnapAnimator;
		143	std::unique_ptr<Timer> m_horizontalScrollSnapTimer;
		144	// FIXME: Find a way to consolidate both timers into one variable.
		145	std::unique_ptr<AxisScrollSnapAnimator> m_verticalScrollSnapAnimator;
		146	std::unique_ptr<Timer> m_verticalScrollSnapTimer;
		147	#endif
137	};	148	};
138		149
139	} // namespace WebCore	150	} // namespace WebCore

Lines 1-144 a/Source/WebCore/platform/cocoa/ScrollController.h_sec1
- a/Source/WebCore/platform/cocoa/ScrollController.h -144 lines
1	/*
2	* Copyright (C) 2011, 2014-2015 Apple Inc. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions
6	* are met:
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	*
13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23	* THE POSSIBILITY OF SUCH DAMAGE.
24	*/
25
26	#ifndef ScrollController_h
27	#define ScrollController_h
28
29	#if ENABLE(RUBBER_BANDING)
30
31	#include "FloatPoint.h"
32	#include "FloatSize.h"
33	#include "ScrollTypes.h"
34	#include <wtf/Noncopyable.h>
35	#include <wtf/RunLoop.h>
36
37	#if ENABLE(CSS_SCROLL_SNAP)
38	#include "AxisScrollSnapAnimator.h"
39	#endif
40
41	namespace WebCore {
42
43	class PlatformWheelEvent;
44	class ScrollableArea;
45
46	class ScrollControllerClient {
47	protected:
48	virtual ~ScrollControllerClient() { }
49
50	public:
51	virtual bool allowsHorizontalStretching(const PlatformWheelEvent&) = 0;
52	virtual bool allowsVerticalStretching(const PlatformWheelEvent&) = 0;
53	virtual IntSize stretchAmount() = 0;
54	virtual bool pinnedInDirection(const FloatSize&) = 0;
55	virtual bool canScrollHorizontally() = 0;
56	virtual bool canScrollVertically() = 0;
57	virtual bool shouldRubberBandInDirection(ScrollDirection) = 0;
58
59	// Return the absolute scroll position, not relative to the scroll origin.
60	virtual WebCore::IntPoint absoluteScrollPosition() = 0;
61
62	virtual void immediateScrollBy(const FloatSize&) = 0;
63	virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) = 0;
64
65	// If the current scroll position is within the overhang area, this function will cause
66	// the page to scroll to the nearest boundary point.
67	virtual void adjustScrollPositionToBoundsIfNecessary() = 0;
68
69	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
70	virtual LayoutUnit scrollOffsetOnAxis(ScrollEventAxis) = 0;
71	virtual void immediateScrollOnAxis(ScrollEventAxis, float delta) = 0;
72	#endif
73	};
74
75	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
76	class ScrollController : public AxisScrollSnapAnimatorClient {
77	#else
78	class ScrollController {
79	#endif
80	WTF_MAKE_NONCOPYABLE(ScrollController);
81
82	public:
83	explicit ScrollController(ScrollControllerClient*);
84
85	bool handleWheelEvent(const PlatformWheelEvent&);
86
87	bool isRubberBandInProgress() const;
88
89	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
90	bool processWheelEventForScrollSnap(const PlatformWheelEvent&);
91	void updateScrollAnimatorsAndTimers(const ScrollableArea&);
92	#endif
93
94	private:
95	void startSnapRubberbandTimer();
96	void stopSnapRubberbandTimer();
97	void snapRubberBand();
98	void snapRubberBandTimerFired();
99
100	bool shouldRubberBandInHorizontalDirection(const PlatformWheelEvent&);
101
102	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
103	void horizontalScrollSnapTimerFired();
104	void verticalScrollSnapTimerFired();
105	void startScrollSnapTimer(ScrollEventAxis);
106	void stopScrollSnapTimer(ScrollEventAxis);
107
108	LayoutUnit scrollOffsetOnAxis(ScrollEventAxis) override;
109	void immediateScrollOnAxis(ScrollEventAxis, float delta) override;
110	#endif
111
112	ScrollControllerClient* m_client;
113
114	CFTimeInterval m_lastMomentumScrollTimestamp;
115	FloatSize m_overflowScrollDelta;
116	FloatSize m_stretchScrollForce;
117	FloatSize m_momentumVelocity;
118
119	// Rubber band state.
120	CFTimeInterval m_startTime;
121	FloatSize m_startStretch;
122	FloatPoint m_origOrigin;
123	FloatSize m_origVelocity;
124	RunLoop::Timer<ScrollController> m_snapRubberbandTimer;
125
126	#if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
127	// FIXME: Find a way to consolidate both timers into one variable.
128	std::unique_ptr<AxisScrollSnapAnimator> m_horizontalScrollSnapAnimator;
129	std::unique_ptr<AxisScrollSnapAnimator> m_verticalScrollSnapAnimator;
130	RunLoop::Timer<ScrollController> m_horizontalScrollSnapTimer;
131	RunLoop::Timer<ScrollController> m_verticalScrollSnapTimer;
132	#endif
133
134	bool m_inScrollGesture;
135	bool m_momentumScrollInProgress;
136	bool m_ignoreMomentumScrolls;
137	bool m_snapRubberbandTimerIsActive;
138	};
139
140	} // namespace WebCore
141
142	#endif // ENABLE(RUBBER_BANDING)
143
144	#endif // ScrollController_h

Lines 57-64 protected: a/Source/WebCore/platform/mac/AxisScrollSnapAnimator.h_sec1
- a/Source/WebCore/platform/mac/AxisScrollSnapAnimator.h -2 / +2 lines
57	virtual ~AxisScrollSnapAnimatorClient() { }	57	virtual ~AxisScrollSnapAnimatorClient() { }
58		58
59	public:	59	public:
60	virtual LayoutUnit scrollOffsetOnAxis(ScrollEventAxis) = 0;	60	virtual LayoutUnit scrollOffsetInAxis(ScrollEventAxis) = 0;
61	virtual void immediateScrollOnAxis(ScrollEventAxis, float velocity) = 0;	61	virtual void immediateScrollInAxis(ScrollEventAxis, float velocity) = 0;
62	virtual void startScrollSnapTimer(ScrollEventAxis) = 0;	62	virtual void startScrollSnapTimer(ScrollEventAxis) = 0;
63	virtual void stopScrollSnapTimer(ScrollEventAxis) = 0;	63	virtual void stopScrollSnapTimer(ScrollEventAxis) = 0;
64	};	64	};

Lines 117-123 void AxisScrollSnapAnimator::handleWheelEvent(const PlatformWheelEvent& event) a/Source/WebCore/platform/mac/AxisScrollSnapAnimator.mm_sec1
- a/Source/WebCore/platform/mac/AxisScrollSnapAnimator.mm -5 / +5 lines
117	// Begin tracking wheel deltas for glide prediction.	117	// Begin tracking wheel deltas for glide prediction.
118	endScrollSnapAnimation(ScrollSnapState::UserInteraction);	118	endScrollSnapAnimation(ScrollSnapState::UserInteraction);
119	pushInitialWheelDelta(wheelDelta);	119	pushInitialWheelDelta(wheelDelta);
120	m_beginTrackingWheelDeltaOffset = m_client->scrollOffsetOnAxis(m_axis);	120	m_beginTrackingWheelDeltaOffset = m_client->scrollOffsetInAxis(m_axis);
121	break;	121	break;
122		122
123	case WheelEventStatus::InertialScrolling:	123	case WheelEventStatus::InertialScrolling:
Lines 153-159 void AxisScrollSnapAnimator::scrollSnapAnimationUpdate() a/Source/WebCore/platform/mac/AxisScrollSnapAnimator.mm_sec2
153	ASSERT(m_currentState == ScrollSnapState::Gliding \|\| m_currentState == ScrollSnapState::Snapping);	153	ASSERT(m_currentState == ScrollSnapState::Gliding \|\| m_currentState == ScrollSnapState::Snapping);
154	float delta = m_currentState == ScrollSnapState::Snapping ? computeSnapDelta() : computeGlideDelta();	154	float delta = m_currentState == ScrollSnapState::Snapping ? computeSnapDelta() : computeGlideDelta();
155	if (delta)	155	if (delta)
156	m_client->immediateScrollOnAxis(m_axis, delta);	156	m_client->immediateScrollInAxis(m_axis, delta);
157	else	157	else
158	endScrollSnapAnimation(ScrollSnapState::DestinationReached);	158	endScrollSnapAnimation(ScrollSnapState::DestinationReached);
159	}	159	}
Lines 161-167 void AxisScrollSnapAnimator::scrollSnapAnimationUpdate() a/Source/WebCore/platform/mac/AxisScrollSnapAnimator.mm_sec3
161	void AxisScrollSnapAnimator::beginScrollSnapAnimation(ScrollSnapState newState)	161	void AxisScrollSnapAnimator::beginScrollSnapAnimation(ScrollSnapState newState)
162	{	162	{
163	ASSERT(newState == ScrollSnapState::Gliding \|\| newState == ScrollSnapState::Snapping);	163	ASSERT(newState == ScrollSnapState::Gliding \|\| newState == ScrollSnapState::Snapping);
164	LayoutUnit offset = m_client->scrollOffsetOnAxis(m_axis);	164	LayoutUnit offset = m_client->scrollOffsetInAxis(m_axis);
165	float initialWheelDelta = newState == ScrollSnapState::Gliding ? averageInitialWheelDelta() : 0;	165	float initialWheelDelta = newState == ScrollSnapState::Gliding ? averageInitialWheelDelta() : 0;
166	LayoutUnit projectedScrollDestination = newState == ScrollSnapState::Gliding ? m_beginTrackingWheelDeltaOffset + LayoutUnit(projectedInertialScrollDistance(initialWheelDelta)) : offset;	166	LayoutUnit projectedScrollDestination = newState == ScrollSnapState::Gliding ? m_beginTrackingWheelDeltaOffset + LayoutUnit(projectedInertialScrollDistance(initialWheelDelta)) : offset;
167	projectedScrollDestination = std::min(std::max(projectedScrollDestination, m_snapOffsets->first()), m_snapOffsets->last());	167	projectedScrollDestination = std::min(std::max(projectedScrollDestination, m_snapOffsets->first()), m_snapOffsets->last());
Lines 203-209 void AxisScrollSnapAnimator::endScrollSnapAnimation(ScrollSnapState newState) a/Source/WebCore/platform/mac/AxisScrollSnapAnimator.mm_sec4
203	// relationship of the distance traveled, clamped by arbitrary min and max values.	203	// relationship of the distance traveled, clamped by arbitrary min and max values.
204	float AxisScrollSnapAnimator::computeSnapDelta() const	204	float AxisScrollSnapAnimator::computeSnapDelta() const
205	{	205	{
206	LayoutUnit offset = m_client->scrollOffsetOnAxis(m_axis);	206	LayoutUnit offset = m_client->scrollOffsetInAxis(m_axis);
207	bool canComputeSnap = (m_initialOffset <= offset && offset < m_targetOffset) \|\| (m_targetOffset < offset && offset <= m_initialOffset);	207	bool canComputeSnap = (m_initialOffset <= offset && offset < m_targetOffset) \|\| (m_targetOffset < offset && offset <= m_initialOffset);
208	if (m_currentState != ScrollSnapState::Snapping \|\| !canComputeSnap)	208	if (m_currentState != ScrollSnapState::Snapping \|\| !canComputeSnap)
209	return 0;	209	return 0;
Lines 237-243 float AxisScrollSnapAnimator::computeSnapDelta() const a/Source/WebCore/platform/mac/AxisScrollSnapAnimator.mm_sec5
237	// and VF. Thus, we can express our gliding equation all in terms of V0, VF and t.	237	// and VF. Thus, we can express our gliding equation all in terms of V0, VF and t.
238	float AxisScrollSnapAnimator::computeGlideDelta() const	238	float AxisScrollSnapAnimator::computeGlideDelta() const
239	{	239	{
240	LayoutUnit offset = m_client->scrollOffsetOnAxis(m_axis);	240	LayoutUnit offset = m_client->scrollOffsetInAxis(m_axis);
241	bool canComputeGlide = (m_initialOffset <= offset && offset < m_targetOffset) \|\| (m_targetOffset < offset && offset <= m_initialOffset);	241	bool canComputeGlide = (m_initialOffset <= offset && offset < m_targetOffset) \|\| (m_targetOffset < offset && offset <= m_initialOffset);
242	if (m_currentState != ScrollSnapState::Gliding \|\| !canComputeGlide)	242	if (m_currentState != ScrollSnapState::Gliding \|\| !canComputeGlide)
243	return 0;	243	return 0;

Line 0 a/Source/WebCore/platform/mac/ScrollController.h_sec1
- a/Source/WebCore/platform/mac/ScrollController.h +107 lines
		1	/*
		2	* Copyright (C) 2011 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
		14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
		17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
		23	* THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#ifndef ScrollController_h
		27	#define ScrollController_h
		28
		29	#if ENABLE(RUBBER_BANDING)
		30
		31	#include "FloatPoint.h"
		32	#include "FloatSize.h"
		33	#include "ScrollTypes.h"
		34	#include <wtf/Noncopyable.h>
		35
		36	namespace WebCore {
		37
		38	class PlatformWheelEvent;
		39
		40	class ScrollControllerClient {
		41	protected:
		42	virtual ~ScrollControllerClient() { }
		43
		44	public:
		45	virtual bool allowsHorizontalStretching(const PlatformWheelEvent&) = 0;
		46	virtual bool allowsVerticalStretching(const PlatformWheelEvent&) = 0;
		47	virtual IntSize stretchAmount() = 0;
		48	virtual bool pinnedInDirection(const FloatSize&) = 0;
		49	virtual bool canScrollHorizontally() = 0;
		50	virtual bool canScrollVertically() = 0;
		51	virtual bool shouldRubberBandInDirection(ScrollDirection) = 0;
		52
		53	// Return the absolute scroll position, not relative to the scroll origin.
		54	virtual WebCore::IntPoint absoluteScrollPosition() = 0;
		55
		56	virtual void immediateScrollBy(const FloatSize&) = 0;
		57	virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) = 0;
		58	virtual void startSnapRubberbandTimer() = 0;
		59	virtual void stopSnapRubberbandTimer() = 0;
		60
		61	// If the current scroll position is within the overhang area, this function will cause
		62	// the page to scroll to the nearest boundary point.
		63	virtual void adjustScrollPositionToBoundsIfNecessary() = 0;
		64	};
65
66	class ScrollController {
67	WTF_MAKE_NONCOPYABLE(ScrollController);
68
69	public:
70	explicit ScrollController(ScrollControllerClient*);
71
72	bool handleWheelEvent(const PlatformWheelEvent&);
73	void snapRubberBandTimerFired();
74
75	bool isRubberBandInProgress() const;
76
77	private:
78	void stopSnapRubberbandTimer();
79	void snapRubberBand();
80
81	bool shouldRubberBandInHorizontalDirection(const PlatformWheelEvent&);
82
83	ScrollControllerClient* m_client;
84
85	bool m_inScrollGesture;
86	bool m_momentumScrollInProgress;
87	bool m_ignoreMomentumScrolls;
88
89	CFTimeInterval m_lastMomentumScrollTimestamp;
90	FloatSize m_overflowScrollDelta;
91	FloatSize m_stretchScrollForce;
92	FloatSize m_momentumVelocity;
93
94	// Rubber band state.
95	CFTimeInterval m_startTime;
96	FloatSize m_startStretch;
97	FloatPoint m_origOrigin;
98	FloatSize m_origVelocity;
99
100	bool m_snapRubberbandTimerIsActive;
101	};
102
103	} // namespace WebCore
104
105	#endif // ENABLE(RUBBER_BANDING)
106
107	#endif // ScrollController_h