ChangeLog

2014-08-14  Wenson Hsieh  <wenson_hsieh@apple.com>

        Implement snapping behavior for iOS

        https://bugs.webkit.org/show_bug.cgi?id=135769

        Reviewed by NOBODY (OOPS!).

        Added support for snap points on iOS. This entails sending snap points from the web process to the UI process

        by encoding and decoding snap points and updating ScrollingTreeOverflowScrollingNodeIOS and WKWebView to support

        animation to snap points in the cases of mainframe and overflow scrolling, respectively.

        There are no new tests yet -- we'll need to find a way to test this!

        * WebCore.exp.in:

        * page/scrolling/AsyncScrollingCoordinator.cpp:

        (WebCore::setStateScrollingNodeSnapOffsetsAsFloat): Helper functions used to convert LayoutUnits to floats for snap offsets.

        (WebCore::AsyncScrollingCoordinator::frameViewLayoutUpdated): Update snap offsets for mainframe scrolling, as well as the state node.

        (WebCore::AsyncScrollingCoordinator::updateOverflowScrollingNode): Added snap offsets.

        * page/scrolling/AxisScrollSnapOffsets.h:

        (WebCore::closestSnapOffset): Computes the closest snap offset given a sorted vector of comparable types (e.g. float, LayoutUnit).

        * page/scrolling/ScrollingCoordinator.h:

        * page/scrolling/ScrollingStateScrollingNode.cpp:

        (WebCore::ScrollingStateScrollingNode::ScrollingStateScrollingNode):

        (WebCore::ScrollingStateScrollingNode::setHorizontalSnapOffsets):

        (WebCore::ScrollingStateScrollingNode::setVerticalSnapOffsets):

        * page/scrolling/ScrollingStateScrollingNode.h:

        (WebCore::ScrollingStateScrollingNode::horizontalSnapOffsets):

        (WebCore::ScrollingStateScrollingNode::verticalSnapOffsets):

        * page/scrolling/ScrollingTreeScrollingNode.cpp:

        (WebCore::ScrollingTreeScrollingNode::updateBeforeChildren):

        * page/scrolling/ScrollingTreeScrollingNode.h:

        (WebCore::ScrollingTreeScrollingNode::horizontalSnapOffsets):

        (WebCore::ScrollingTreeScrollingNode::verticalSnapOffsets):

        * rendering/RenderLayer.cpp:

        (WebCore::RenderLayer::updateScrollInfoAfterLayout): Update snap offsets for overflow scrolling.

        * rendering/RenderLayerCompositor.cpp:

        (WebCore::RenderLayerCompositor::updateScrollCoordinatedLayer): Updates the state node's snap offsets for overflow scrolling.

2014-08-14  Brent Fulgham  <bfulgham@apple.com>

        [Win] Correct build when DerivedSources location not supplied by build environment

Source/WebKit2/ChangeLog

2014-08-14  Wenson Hsieh  <wenson_hsieh@apple.com>

        Implement snapping behavior for iOS

        https://bugs.webkit.org/show_bug.cgi?id=135769

        Reviewed by NOBODY (OOPS!).

        * Shared/Scrolling/RemoteScrollingCoordinatorTransaction.cpp:

        (ArgumentCoder<ScrollingStateScrollingNode>::encode): Added snap offset encoding.

        (ArgumentCoder<ScrollingStateScrollingNode>::decode): Added snap offset decoding.

        * UIProcess/API/Cocoa/WKWebView.mm:

        (-[WKWebView scrollViewWillEndDragging:withVelocity:targetContentOffset:]): For mainframe scrolling, retargets the scroll destination to the appropriate snap point.

        * UIProcess/Scrolling/RemoteScrollingCoordinatorProxy.h: Added methods to extract relevant information for WKWebView from snap offsets in mainframe scrolling.

        * UIProcess/Scrolling/ios/ScrollingTreeOverflowScrollingNodeIOS.mm:

        (-[WKOverflowScrollViewDelegate scrollViewWillEndDragging:withVelocity:targetContentOffset:]): For overflow scrolling, retargets the scroll destination to the appropriate snap point.

        (WebKit::ScrollingTreeOverflowScrollingNodeIOS::updateAfterChildren): Sets the deceleration factor to FAST if snap points are active.

        * UIProcess/ios/RemoteScrollingCoordinatorProxyIOS.mm:

        (WebKit::RemoteScrollingCoordinatorProxy::adjustTargetContentOffsetForSnapping):

        (WebKit::RemoteScrollingCoordinatorProxy::shouldSnapForMainFrameScrolling):

        (WebKit::RemoteScrollingCoordinatorProxy::closestSnapOffsetForMainFrameScrolling): Invoked by WKWebView to retarget the scroll destination.

2014-08-14  Enrica Casucci  <enrica@apple.com>

        [Services with UI] Selection services don't work inside <iframes>.

Source/WebCore/WebCore.exp.in

@@__ZN7WebCore4toJSEPN3JSC9ExecStateEPNS_17JSDOMGlobalObjectEPNS_12DOMWindowCSSE

__ZN7WebCore16FilterOperationsaSERKS0_

#endif

#if ENABLE(CSS_SCROLL_SNAP)

__ZN7WebCore27ScrollingStateScrollingNode22setVerticalSnapOffsetsERKN3WTF6VectorIfLm0ENS1_15CrashOnOverflowEEE

__ZN7WebCore27ScrollingStateScrollingNode24setHorizontalSnapOffsetsERKN3WTF6VectorIfLm0ENS1_15CrashOnOverflowEEE

#endif

#if ENABLE(DASHBOARD_SUPPORT)

__ZNK7WebCore8Document16annotatedRegionsEv

#endif

Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp

@@void AsyncScrollingCoordinator::scrollingStateTreePropertiesChanged()

    scheduleTreeStateCommit();

}

static inline void setStateScrollingNodeSnapOffsetsAsFloat(ScrollEventAxis axis, ScrollingStateScrollingNode* node, const Vector<LayoutUnit>& snapOffsets, float deviceScaleFactor)

{

    ASSERT(node);

    Vector<float> snapOffsetsAsFloat;

    snapOffsetsAsFloat.reserveCapacity(snapOffsets.size());

    for (size_t i = 0; i < snapOffsets.size(); i++)

        snapOffsetsAsFloat.append(roundToDevicePixel(snapOffsets[i], deviceScaleFactor, false));

    if (axis == ScrollEventAxis::Horizontal)

        node->setHorizontalSnapOffsets(snapOffsetsAsFloat);

    else

        node->setVerticalSnapOffsets(snapOffsetsAsFloat);

}

void AsyncScrollingCoordinator::frameViewLayoutUpdated(FrameView* frameView)

{

    ASSERT(isMainThread());

@@void AsyncScrollingCoordinator::frameViewLayoutUpdated(FrameView* frameView)

    node->setTotalContentsSize(frameView->totalContentsSize());

    node->setReachableContentsSize(frameView->totalContentsSize());

#if ENABLE(CSS_SCROLL_SNAP)

    frameView->updateSnapOffsets();

    if (frameView->horizontalSnapOffsets())

        setStateScrollingNodeSnapOffsetsAsFloat(ScrollEventAxis::Horizontal, node, *frameView->horizontalSnapOffsets(), frameView->frame().document()->deviceScaleFactor());

    if (frameView->verticalSnapOffsets())

        setStateScrollingNodeSnapOffsetsAsFloat(ScrollEventAxis::Vertical, node, *frameView->verticalSnapOffsets(), frameView->frame().document()->deviceScaleFactor());

#endif

    ScrollableAreaParameters scrollParameters;

    scrollParameters.horizontalScrollElasticity = frameView->horizontalScrollElasticity();

    scrollParameters.verticalScrollElasticity = frameView->verticalScrollElasticity();

@@void AsyncScrollingCoordinator::updateOverflowScrollingNode(ScrollingNodeID node

        node->setTotalContentsSize(scrollingGeometry->contentSize);

        node->setReachableContentsSize(scrollingGeometry->reachableContentSize);

        node->setScrollableAreaSize(scrollingGeometry->scrollableAreaSize);

#if ENABLE(CSS_SCROLL_SNAP)

        setStateScrollingNodeSnapOffsetsAsFloat(ScrollEventAxis::Horizontal, node, scrollingGeometry->horizontalSnapOffsets, scrolledContentsLayer->deviceScaleFactor());

        setStateScrollingNodeSnapOffsetsAsFloat(ScrollEventAxis::Vertical, node, scrollingGeometry->verticalSnapOffsets, scrolledContentsLayer->deviceScaleFactor());

#endif

    }

}

Source/WebCore/page/scrolling/AxisScrollSnapOffsets.h

@@class ScrollableArea;

void updateSnapOffsetsForScrollableArea(ScrollableArea&, HTMLElement& scrollingElement, const RenderBox& scrollingElementBox, const RenderStyle& scrollingElementStyle);

template<typename T>

T closestSnapOffset(const Vector<T>& snapOffsets, T scrollDestination, float velocity)

{

    ASSERT(snapOffsets.size());

    if (scrollDestination <= snapOffsets.first())

        return snapOffsets.first();

    if (scrollDestination >= snapOffsets.last())

        return snapOffsets.last();

    size_t lowerIndex = 0;

    size_t upperIndex = snapOffsets.size() - 1;

    while (lowerIndex < upperIndex - 1) {

        size_t middleIndex = (lowerIndex + upperIndex) / 2;

        if (scrollDestination < snapOffsets[middleIndex])

            upperIndex = middleIndex;

        else if (scrollDestination > snapOffsets[middleIndex])

            lowerIndex = middleIndex;

        else {

            upperIndex = middleIndex;

            lowerIndex = middleIndex;

            break;

        }

    }

    T lowerSnapPosition = snapOffsets[lowerIndex];

    T upperSnapPosition = snapOffsets[upperIndex];

    // Nonzero velocity indicates a flick gesture. Even if another snap point is closer, snap to the one in the direction of the flick gesture.

    if (velocity)

        return velocity < 0 ? lowerSnapPosition : upperSnapPosition;

    bool isCloserToLowerSnapPosition = scrollDestination - lowerSnapPosition <= upperSnapPosition - scrollDestination;

    return isCloserToLowerSnapPosition ? lowerSnapPosition : upperSnapPosition;

}

} // namespace WebCore

#endif // CSS_SCROLL_SNAP

Source/WebCore/page/scrolling/ScrollingCoordinator.h

#include <wtf/RetainPtr.h>

#endif

#if ENABLE(CSS_SCROLL_SNAP)

#include "AxisScrollSnapOffsets.h"

#endif

namespace WebCore {

typedef unsigned SynchronousScrollingReasons;

@@public:

        FloatSize reachableContentSize; // Smaller than contentSize when overflow is hidden on one axis.

        FloatPoint scrollPosition;

        IntPoint scrollOrigin;

#if ENABLE(CSS_SCROLL_SNAP)

        Vector<LayoutUnit> horizontalSnapOffsets;

        Vector<LayoutUnit> verticalSnapOffsets;

#endif

    };

    virtual void updateFrameScrollingNode(ScrollingNodeID, GraphicsLayer* /*scrollLayer*/, GraphicsLayer* /*scrolledContentsLayer*/, GraphicsLayer* /*counterScrollingLayer*/, GraphicsLayer* /*insetClipLayer*/, const ScrollingGeometry* = nullptr) { }

Source/WebCore/page/scrolling/ScrollingStateScrollingNode.cpp

@@ScrollingStateScrollingNode::ScrollingStateScrollingNode(const ScrollingStateScr

    , m_scrollPosition(stateNode.scrollPosition())

    , m_requestedScrollPosition(stateNode.requestedScrollPosition())

    , m_scrollOrigin(stateNode.scrollOrigin())

#if ENABLE(CSS_SCROLL_SNAP)

    , m_horizontalSnapOffsets(stateNode.horizontalSnapOffsets())

    , m_verticalSnapOffsets(stateNode.verticalSnapOffsets())

#endif

    , m_scrollableAreaParameters(stateNode.scrollableAreaParameters())

    , m_requestedScrollPositionRepresentsProgrammaticScroll(stateNode.requestedScrollPositionRepresentsProgrammaticScroll())

{

@@void ScrollingStateScrollingNode::setScrollOrigin(const IntPoint& scrollOrigin)

    setPropertyChanged(ScrollOrigin);

}

#if ENABLE(CSS_SCROLL_SNAP)

void ScrollingStateScrollingNode::setHorizontalSnapOffsets(const Vector<float>& snapOffsets)

{

    if (m_horizontalSnapOffsets == snapOffsets)

        return;

    m_horizontalSnapOffsets = snapOffsets;

    setPropertyChanged(HorizontalSnapOffsets);

}

void ScrollingStateScrollingNode::setVerticalSnapOffsets(const Vector<float>& snapOffsets)

{

    if (m_verticalSnapOffsets == snapOffsets)

        return;

    m_verticalSnapOffsets = snapOffsets;

    setPropertyChanged(VerticalSnapOffsets);

}

#endif

void ScrollingStateScrollingNode::setScrollableAreaParameters(const ScrollableAreaParameters& parameters)

{

    if (m_scrollableAreaParameters == parameters)

Source/WebCore/page/scrolling/ScrollingStateScrollingNode.h

@@public:

        ScrollableAreaParams,

        RequestedScrollPosition,

        NumScrollingStateNodeBits,

#if ENABLE(CSS_SCROLL_SNAP)

        HorizontalSnapOffsets,

        VerticalSnapOffsets,

#endif

    };

    const FloatSize& scrollableAreaSize() const { return m_scrollableAreaSize; }

@@public:

    const IntPoint& scrollOrigin() const { return m_scrollOrigin; }

    void setScrollOrigin(const IntPoint&);

#if ENABLE(CSS_SCROLL_SNAP)

    const Vector<float>& horizontalSnapOffsets() const { return m_horizontalSnapOffsets; }

    void setHorizontalSnapOffsets(const Vector<float>&);

    const Vector<float>& verticalSnapOffsets() const { return m_verticalSnapOffsets; }

    void setVerticalSnapOffsets(const Vector<float>&);

#endif

    const ScrollableAreaParameters& scrollableAreaParameters() const { return m_scrollableAreaParameters; }

    void setScrollableAreaParameters(const ScrollableAreaParameters& params);

@@private:

    FloatPoint m_scrollPosition;

    FloatPoint m_requestedScrollPosition;

    IntPoint m_scrollOrigin;

#if ENABLE(CSS_SCROLL_SNAP)

    Vector<float> m_horizontalSnapOffsets;

    Vector<float> m_verticalSnapOffsets;

#endif

    ScrollableAreaParameters m_scrollableAreaParameters;

    bool m_requestedScrollPositionRepresentsProgrammaticScroll;

};

Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp

@@void ScrollingTreeScrollingNode::updateBeforeChildren(const ScrollingStateNode&

    if (state.hasChangedProperty(ScrollingStateScrollingNode::ScrollOrigin))

        m_scrollOrigin = state.scrollOrigin();

#if ENABLE(CSS_SCROLL_SNAP)

    if (state.hasChangedProperty(ScrollingStateScrollingNode::HorizontalSnapOffsets))

        m_horizontalSnapOffsets = state.horizontalSnapOffsets();

    if (state.hasChangedProperty(ScrollingStateScrollingNode::VerticalSnapOffsets))

        m_verticalSnapOffsets = state.verticalSnapOffsets();

#endif

    if (state.hasChangedProperty(ScrollingStateScrollingNode::ScrollableAreaParams))

        m_scrollableAreaParameters = state.scrollableAreaParameters();

}

Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.h

@@public:

    virtual FloatPoint scrollPosition() const = 0;

#if ENABLE(CSS_SCROLL_SNAP)

    const Vector<float>& horizontalSnapOffsets() const { return m_horizontalSnapOffsets; }

    const Vector<float>& verticalSnapOffsets() const { return m_verticalSnapOffsets; }

#endif

protected:

    ScrollingTreeScrollingNode(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);

@@private:

    FloatSize m_reachableContentsSize;

    FloatPoint m_lastCommittedScrollPosition;

    IntPoint m_scrollOrigin;

95

#if ENABLE(CSS_SCROLL_SNAP)

    Vector<float> m_horizontalSnapOffsets;

    Vector<float> m_verticalSnapOffsets;

#endif

    ScrollableAreaParameters m_scrollableAreaParameters;

};

Source/WebCore/rendering/RenderLayer.cpp

@@void RenderLayer::updateScrollInfoAfterLayout()

    // Composited scrolling may need to be enabled or disabled if the amount of overflow changed.

    if (compositor().updateLayerCompositingState(*this))

        compositor().setCompositingLayersNeedRebuild();

#if ENABLE(CSS_SCROLL_SNAP)

    // FIXME: Ensure that offsets are also updated in case of programmatic style changes.

    // https://bugs.webkit.org/show_bug.cgi?id=135964

    updateSnapOffsets();

#endif

}

bool RenderLayer::overflowControlsIntersectRect(const IntRect& localRect) const

Source/WebCore/rendering/RenderLayerCompositor.cpp

@@void RenderLayerCompositor::updateScrollCoordinatedLayer(RenderLayer& layer, Scr

            scrollingGeometry.scrollableAreaSize = layer.visibleSize();

            scrollingGeometry.contentSize = layer.contentsSize();

            scrollingGeometry.reachableContentSize = layer.scrollableContentsSize();

#if ENABLE(CSS_SCROLL_SNAP)

            if (auto* offsets = layer.horizontalSnapOffsets())

                scrollingGeometry.horizontalSnapOffsets = *offsets;

            if (auto* offsets = layer.verticalSnapOffsets())

                scrollingGeometry.verticalSnapOffsets = *offsets;

#endif

            scrollingCoordinator->updateOverflowScrollingNode(nodeID, backing->scrollingLayer(), backing->scrollingContentsLayer(), &scrollingGeometry);

        }

    }

Source/WebKit2/Shared/Scrolling/RemoteScrollingCoordinatorTransaction.cpp

@@void ArgumentCoder<ScrollingStateScrollingNode>::encode(ArgumentEncoder& encoder

    SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::ReachableContentsSize, reachableContentsSize)

    SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::ScrollPosition, scrollPosition)

    SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::ScrollOrigin, scrollOrigin)

#if ENABLE(CSS_SCROLL_SNAP)

    SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::HorizontalSnapOffsets, horizontalSnapOffsets)

    SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::VerticalSnapOffsets, verticalSnapOffsets)

#endif

    SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::ScrollableAreaParams, scrollableAreaParameters)

    SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::RequestedScrollPosition, requestedScrollPosition)

    SCROLLING_NODE_ENCODE(ScrollingStateScrollingNode::RequestedScrollPosition, requestedScrollPositionRepresentsProgrammaticScroll)

@@bool ArgumentCoder<ScrollingStateScrollingNode>::decode(ArgumentDecoder& decoder

    SCROLLING_NODE_DECODE(ScrollingStateScrollingNode::ReachableContentsSize, FloatSize, setReachableContentsSize);

    SCROLLING_NODE_DECODE(ScrollingStateScrollingNode::ScrollPosition, FloatPoint, setScrollPosition);

    SCROLLING_NODE_DECODE(ScrollingStateScrollingNode::ScrollOrigin, IntPoint, setScrollOrigin);

#if ENABLE(CSS_SCROLL_SNAP)

    SCROLLING_NODE_DECODE(ScrollingStateScrollingNode::HorizontalSnapOffsets, Vector<float>, setHorizontalSnapOffsets);

    SCROLLING_NODE_DECODE(ScrollingStateScrollingNode::VerticalSnapOffsets, Vector<float>, setVerticalSnapOffsets);

#endif

    SCROLLING_NODE_DECODE(ScrollingStateScrollingNode::ScrollableAreaParams, ScrollableAreaParameters, setScrollableAreaParameters);

    if (node.hasChangedProperty(ScrollingStateScrollingNode::RequestedScrollPosition)) {

Source/WebKit2/UIProcess/API/Cocoa/WKWebView.mm

#import "PrintInfo.h"

#import "ProcessThrottler.h"

#import "RemoteLayerTreeDrawingAreaProxy.h"

86#import "RemoteScrollingCoordinatorProxy.h"

#import "WKPDFView.h"

#import "WKScrollView.h"

#import "WKWebViewContentProviderRegistry.h"

@@static WebCore::FloatPoint constrainContentOffset(WebCore::FloatPoint contentOff

    // zooming. We'll animate to the right place once the zoom finishes.

    if ([scrollView isZooming])

        *targetContentOffset = [scrollView contentOffset];

#if ENABLE(CSS_SCROLL_SNAP) && ENABLE(ASYNC_SCROLLING)

    if (WebKit::RemoteScrollingCoordinatorProxy* coordinator = _page->scrollingCoordinatorProxy()) {

        CGSize maxScrollDimensions = CGSizeMake(scrollView.contentSize.width - scrollView.bounds.size.width, scrollView.contentSize.height - scrollView.bounds.size.height);

        coordinator->adjustTargetContentOffsetForSnapping(maxScrollDimensions, velocity, targetContentOffset);

    }

#endif

}

- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate

Source/WebKit2/UIProcess/Scrolling/RemoteScrollingCoordinatorProxy.h

@@public:

    void scrollingTreeNodeWillStartPanGesture();

    void scrollingTreeNodeWillStartScroll();

    void scrollingTreeNodeDidEndScroll();

#if ENABLE(CSS_SCROLL_SNAP)

    void adjustTargetContentOffsetForSnapping(CGSize maxScrollDimensions, CGPoint velocity, CGPoint* targetContentOffset) const;

#endif

#endif

private:

    void connectStateNodeLayers(WebCore::ScrollingStateTree&, const RemoteLayerTreeHost&);

#if ENABLE(CSS_SCROLL_SNAP)

    bool shouldSnapForMainFrameScrolling(WebCore::ScrollEventAxis) const;

    float closestSnapOffsetForMainFrameScrolling(WebCore::ScrollEventAxis, float scrollDestination, float velocity) const;

#endif

    WebPageProxy& m_webPageProxy;

    RefPtr<RemoteScrollingTree> m_scrollingTree;

Source/WebKit2/UIProcess/Scrolling/ios/ScrollingTreeOverflowScrollingNodeIOS.mm

#import <UIKit/UIScrollView.h>

#import <wtf/TemporaryChange.h>

#if ENABLE(CSS_SCROLL_SNAP)

#import <WebCore/AxisScrollSnapOffsets.h>

#endif

using namespace WebCore;

@interface WKOverflowScrollViewDelegate : NSObject <UIScrollViewDelegate> {

@@using namespace WebCore;

    _scrollingTreeNode->overflowScrollWillStart();

}

#if ENABLE(CSS_SCROLL_SNAP)

- (void)scrollViewWillEndDragging:(UIScrollView *)scrollView withVelocity:(CGPoint)velocity targetContentOffset:(inout CGPoint *)targetContentOffset

{

    if (_scrollingTreeNode->horizontalSnapOffsets().size() > 0)

        targetContentOffset->x = closestSnapOffset<float>(_scrollingTreeNode->horizontalSnapOffsets(), targetContentOffset->x, velocity.x);

    if (_scrollingTreeNode->verticalSnapOffsets().size() > 0)

        targetContentOffset->y = closestSnapOffset<float>(_scrollingTreeNode->verticalSnapOffsets(), targetContentOffset->y, velocity.y);

}

#endif

- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)willDecelerate

{

    if (_inUserInteraction && !willDecelerate) {

@@void ScrollingTreeOverflowScrollingNodeIOS::updateAfterChildren(const ScrollingS

            scrollView.contentInset = insets;

        }

191

#if ENABLE(CSS_SCROLL_SNAP)

        // FIXME: If only one axis snaps in 2D scrolling, the other axis will decelerate fast as well. Is this what we want?

        if (scrollingStateNode.hasChangedProperty(ScrollingStateScrollingNode::HorizontalSnapOffsets) || scrollingStateNode.hasChangedProperty(ScrollingStateScrollingNode::VerticalSnapOffsets))

            scrollView.decelerationRate = horizontalSnapOffsets().size() || verticalSnapOffsets().size() ? UIScrollViewDecelerationRateFast : UIScrollViewDecelerationRateNormal;

#endif

        END_BLOCK_OBJC_EXCEPTIONS

    }

}

Source/WebKit2/UIProcess/ios/RemoteScrollingCoordinatorProxyIOS.mm

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

26 ~~#include~~ "config.h"

27 ~~#include~~ "RemoteScrollingCoordinatorProxy.h"

26#import "config.h"

27#import "RemoteScrollingCoordinatorProxy.h"

#if PLATFORM(IOS)

#if ENABLE(ASYNC_SCROLLING)

#include "LayerRepresentation.h"

#include "RemoteLayerTreeHost.h"

#include "WebPageProxy.h"

#include <WebCore/ScrollingStateFrameScrollingNode.h>

#include <WebCore/ScrollingStateOverflowScrollingNode.h>

#include <WebCore/ScrollingStateTree.h>

#include <UIKit/UIView.h>

#import "LayerRepresentation.h"

#import "RemoteLayerTreeHost.h"

#import "WebPageProxy.h"

#import <UIKit/UIView.h>

#import <WebCore/ScrollingStateFrameScrollingNode.h>

#import <WebCore/ScrollingStateOverflowScrollingNode.h>

#import <WebCore/ScrollingStateTree.h>

#if ENABLE(CSS_SCROLL_SNAP)

#import <WebCore/AxisScrollSnapOffsets.h>

#import <WebCore/ScrollTypes.h>

#import <WebCore/ScrollingTreeFrameScrollingNode.h>

#endif

using namespace WebCore;

@@void RemoteScrollingCoordinatorProxy::scrollingTreeNodeDidEndScroll()

    m_webPageProxy.overflowScrollDidEndScroll();

}

#if ENABLE(CSS_SCROLL_SNAP)

void RemoteScrollingCoordinatorProxy::adjustTargetContentOffsetForSnapping(CGSize maxScrollDimensions, CGPoint velocity, CGPoint* targetContentOffset) const

{

    if (shouldSnapForMainFrameScrolling(WebCore::ScrollEventAxis::Horizontal) && targetContentOffset->x > 0 && targetContentOffset->x < maxScrollDimensions.width) {

        float potentialSnapPosition = closestSnapOffsetForMainFrameScrolling(WebCore::ScrollEventAxis::Horizontal, targetContentOffset->x, velocity.x);

        targetContentOffset->x = std::min<float>(maxScrollDimensions.width, potentialSnapPosition);

    }

    // FIXME: We should account for how the top navigation bar changes in size.

    if (shouldSnapForMainFrameScrolling(WebCore::ScrollEventAxis::Vertical) && targetContentOffset->y > 0 && targetContentOffset->y < maxScrollDimensions.height) {

        float potentialSnapPosition = closestSnapOffsetForMainFrameScrolling(WebCore::ScrollEventAxis::Vertical, targetContentOffset->y, velocity.y);

        targetContentOffset->y = std::min<float>(maxScrollDimensions.height, potentialSnapPosition);

    }

}

bool RemoteScrollingCoordinatorProxy::shouldSnapForMainFrameScrolling(ScrollEventAxis axis) const

{

    ScrollingTreeNode* root = m_scrollingTree->rootNode();

    if (root && root->isFrameScrollingNode()) {

        ScrollingTreeFrameScrollingNode* rootFrame = static_cast<ScrollingTreeFrameScrollingNode*>(root);

        const Vector<float>& snapOffsets = axis == ScrollEventAxis::Horizontal ? rootFrame->horizontalSnapOffsets() : rootFrame->verticalSnapOffsets();

        return snapOffsets.size() > 0;

    }

    return false;

}

float RemoteScrollingCoordinatorProxy::closestSnapOffsetForMainFrameScrolling(ScrollEventAxis axis, float scrollDestination, float velocity) const

{

    ScrollingTreeNode* root = m_scrollingTree->rootNode();

    ASSERT(root && root->isFrameScrollingNode());

    ScrollingTreeFrameScrollingNode* rootFrame = static_cast<ScrollingTreeFrameScrollingNode*>(root);

    const Vector<float>& snapOffsets = axis == ScrollEventAxis::Horizontal ? rootFrame->horizontalSnapOffsets() : rootFrame->verticalSnapOffsets();

    return closestSnapOffset<float>(snapOffsets, scrollDestination, velocity);

}

#endif

} // namespace WebKit