Use IntSize in RenderLayer to represent scroll offsets
authorjchaffraix@webkit.org <jchaffraix@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 20 Jun 2012 17:24:24 +0000 (17:24 +0000)
committerjchaffraix@webkit.org <jchaffraix@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 20 Jun 2012 17:24:24 +0000 (17:24 +0000)
https://bugs.webkit.org/show_bug.cgi?id=89154

Reviewed by Eric Seidel.

Source/WebCore:

Refactoring, covered by existing tests.

* accessibility/AccessibilityRenderObject.cpp:
(WebCore::AccessibilityRenderObject::scrollTo):
* html/TextFieldInputType.cpp:
(WebCore::TextFieldInputType::forwardEvent):
* page/SpatialNavigation.cpp:
(WebCore::scrollInDirection):
* rendering/RenderMarquee.cpp:
(WebCore::RenderMarquee::start):
Updated those call-sites to use the IntSize variant of the scrolling function.

* rendering/RenderLayer.cpp:
(WebCore::RenderLayer::panScrollFromPoint):
Updated the signature to use IntPoint to avoid an extra round-trip to LayoutPoint
(furthermore touch points should be in device pixels).

(WebCore::RenderLayer::clampScrollOffset):
Added this function that clamps a scroll offset to the box's size. This enables more
code sharing between the different functions. Also removed a NULL-check that shouldn't
be needed: scrolling is a RenderBox concept so any callers should ensure that we have
a RenderBox or it makes no sense to try to scroll.

(WebCore::RenderLayer::updateLayerPosition):
(WebCore::adjustedScrollDelta):
(WebCore::RenderLayer::scrollByRecursively):
(WebCore::RenderLayer::scrollToOffset):
(WebCore::RenderLayer::scrollRectToVisible):
(WebCore::RenderLayer::updateScrollInfoAfterLayout):
Updated to do IntSize arithmetic. Reuse clampScrollOffset when applicable.

* rendering/RenderLayer.h:
(WebCore::RenderLayer::scrollToXOffset):
(WebCore::RenderLayer::scrollToYOffset):
Updated the functions to take IntSize as much as possible.

Source/WebKit/blackberry:

* Api/WebPage.cpp:
(BlackBerry::WebKit::WebPagePrivate::scrollRenderer):
Updated to pass an IntSize to scrollToOffset.

Source/WebKit/win:

* WebView.cpp:
(WebView::gesture):
Updated to pass an IntSize to scrollByRecursively.

Source/WebKit2:

* WebProcess/WebPage/win/WebPageWin.cpp:
(WebKit::WebPage::gestureDidScroll):
Updated to pass an IntSize to scrollByRecursively.

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@120832 268f45cc-cd09-0410-ab3c-d52691b4dbfc

13 files changed:
Source/WebCore/ChangeLog
Source/WebCore/accessibility/AccessibilityRenderObject.cpp
Source/WebCore/html/TextFieldInputType.cpp
Source/WebCore/page/SpatialNavigation.cpp
Source/WebCore/rendering/RenderLayer.cpp
Source/WebCore/rendering/RenderLayer.h
Source/WebCore/rendering/RenderMarquee.cpp
Source/WebKit/blackberry/Api/WebPage.cpp
Source/WebKit/blackberry/ChangeLog
Source/WebKit/win/ChangeLog
Source/WebKit/win/WebView.cpp
Source/WebKit2/ChangeLog
Source/WebKit2/WebProcess/WebPage/win/WebPageWin.cpp

index 63f665a5ff0f781b22ced9feeae1f00fb8f0a341..d7e589069a2a534504e82c1181fec0731c1d7696 100644 (file)
@@ -1,3 +1,46 @@
+2012-06-20  Julien Chaffraix  <jchaffraix@webkit.org>
+
+        Use IntSize in RenderLayer to represent scroll offsets
+        https://bugs.webkit.org/show_bug.cgi?id=89154
+
+        Reviewed by Eric Seidel.
+
+        Refactoring, covered by existing tests.
+
+        * accessibility/AccessibilityRenderObject.cpp:
+        (WebCore::AccessibilityRenderObject::scrollTo):
+        * html/TextFieldInputType.cpp:
+        (WebCore::TextFieldInputType::forwardEvent):
+        * page/SpatialNavigation.cpp:
+        (WebCore::scrollInDirection):
+        * rendering/RenderMarquee.cpp:
+        (WebCore::RenderMarquee::start):
+        Updated those call-sites to use the IntSize variant of the scrolling function.
+
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::panScrollFromPoint):
+        Updated the signature to use IntPoint to avoid an extra round-trip to LayoutPoint
+        (furthermore touch points should be in device pixels).
+
+        (WebCore::RenderLayer::clampScrollOffset):
+        Added this function that clamps a scroll offset to the box's size. This enables more
+        code sharing between the different functions. Also removed a NULL-check that shouldn't
+        be needed: scrolling is a RenderBox concept so any callers should ensure that we have
+        a RenderBox or it makes no sense to try to scroll.
+
+        (WebCore::RenderLayer::updateLayerPosition):
+        (WebCore::adjustedScrollDelta):
+        (WebCore::RenderLayer::scrollByRecursively):
+        (WebCore::RenderLayer::scrollToOffset):
+        (WebCore::RenderLayer::scrollRectToVisible):
+        (WebCore::RenderLayer::updateScrollInfoAfterLayout):
+        Updated to do IntSize arithmetic. Reuse clampScrollOffset when applicable.
+
+        * rendering/RenderLayer.h:
+        (WebCore::RenderLayer::scrollToXOffset):
+        (WebCore::RenderLayer::scrollToYOffset):
+        Updated the functions to take IntSize as much as possible.
+
 2012-06-20  Alexei Filippov  <alexeif@chromium.org>
 
         Web Inspector: mark used/allocated JS heap on the native memory bar chart.
index fd8a644571ed679fc17e817bc25b9eefe8aa8ff6..ba41d21d5f5ce4ad51146a926d5478253c22eb4b 100644 (file)
@@ -4013,7 +4013,7 @@ void AccessibilityRenderObject::scrollTo(const IntPoint& point) const
         return;
 
     RenderLayer* layer = box->layer();
-    layer->scrollToOffset(point.x(), point.y(), RenderLayer::ScrollOffsetClamped);
+    layer->scrollToOffset(toSize(point), RenderLayer::ScrollOffsetClamped);
 }
 
 } // namespace WebCore
index af53255bb62622652875c0681252a06ea2887cf5..7fc40d2a2e9cc2b34d8a6401cd8b534d865d99ca 100644 (file)
@@ -184,8 +184,10 @@ void TextFieldInputType::forwardEvent(Event* event)
         RenderTextControlSingleLine* renderTextControl = toRenderTextControlSingleLine(element()->renderer());
         if (event->type() == eventNames().blurEvent) {
             if (RenderBox* innerTextRenderer = innerTextElement()->renderBox()) {
-                if (RenderLayer* innerLayer = innerTextRenderer->layer())
-                    innerLayer->scrollToOffset(!renderTextControl->style()->isLeftToRightDirection() ? innerLayer->scrollWidth() : 0, 0, RenderLayer::ScrollOffsetClamped);
+                if (RenderLayer* innerLayer = innerTextRenderer->layer()) {
+                    IntSize scrollOffset(!renderTextControl->style()->isLeftToRightDirection() ? innerLayer->scrollWidth() : 0, 0);
+                    innerLayer->scrollToOffset(scrollOffset, RenderLayer::ScrollOffsetClamped);
+                }
             }
 
             renderTextControl->capsLockStateMayHaveChanged();
index 6dcb814a331a714e9300d63307171f2bcb631f98..4150b64f3965d56204ff796b1dc292a3c91ec8da 100644 (file)
@@ -399,7 +399,7 @@ bool scrollInDirection(Node* container, FocusDirection direction)
             return false;
         }
 
-        container->renderBox()->enclosingLayer()->scrollByRecursively(dx, dy);
+        container->renderBox()->enclosingLayer()->scrollByRecursively(IntSize(dx, dy));
         return true;
     }
 
index 2c8676853d34ad19fe084959ef5ab3818c78e6a3..1016da51faf58867160584b7322e2dab6dfbc759 100644 (file)
@@ -846,7 +846,7 @@ void RenderLayer::updateLayerPosition()
             localPoint += columnOffset;
         }
 
-        LayoutSize scrollOffset = parent()->scrolledContentOffset();
+        IntSize scrollOffset = parent()->scrolledContentOffset();
         localPoint -= scrollOffset;
     }
         
@@ -1521,7 +1521,12 @@ static inline int adjustedScrollDelta(int beginningDelta) {
     return adjustedDelta;
 }
 
-void RenderLayer::panScrollFromPoint(const LayoutPoint& sourcePoint) 
+static inline IntSize adjustedScrollDelta(const IntSize& delta)
+{
+    return IntSize(adjustedScrollDelta(delta.width()), adjustedScrollDelta(delta.height()));
+}
+
+void RenderLayer::panScrollFromPoint(const IntPoint& sourcePoint)
 {
     Frame* frame = renderer()->frame();
     if (!frame)
@@ -1536,20 +1541,19 @@ void RenderLayer::panScrollFromPoint(const LayoutPoint& sourcePoint)
     else
         previousMousePosition = currentMousePosition;
 
-    int xDelta = currentMousePosition.x() - sourcePoint.x();
-    int yDelta = currentMousePosition.y() - sourcePoint.y();
+    IntSize delta = currentMousePosition - sourcePoint;
 
-    if (abs(xDelta) <= ScrollView::noPanScrollRadius) // at the center we let the space for the icon
-        xDelta = 0;
-    if (abs(yDelta) <= ScrollView::noPanScrollRadius)
-        yDelta = 0;
+    if (abs(delta.width()) <= ScrollView::noPanScrollRadius) // at the center we let the space for the icon
+        delta.setWidth(0);
+    if (abs(delta.height()) <= ScrollView::noPanScrollRadius)
+        delta.setHeight(0);
 
-    scrollByRecursively(adjustedScrollDelta(xDelta), adjustedScrollDelta(yDelta), ScrollOffsetClamped);
+    scrollByRecursively(adjustedScrollDelta(delta), ScrollOffsetClamped);
 }
 
-void RenderLayer::scrollByRecursively(int xDelta, int yDelta, ScrollOffsetClamping clamp)
+void RenderLayer::scrollByRecursively(const IntSize& delta, ScrollOffsetClamping clamp)
 {
-    if (!xDelta && !yDelta)
+    if (delta.isZero())
         return;
 
     bool restrictedByLineClamp = false;
@@ -1557,16 +1561,14 @@ void RenderLayer::scrollByRecursively(int xDelta, int yDelta, ScrollOffsetClampi
         restrictedByLineClamp = !renderer()->parent()->style()->lineClamp().isNone();
 
     if (renderer()->hasOverflowClip() && !restrictedByLineClamp) {
-        int newOffsetX = scrollXOffset() + xDelta;
-        int newOffsetY = scrollYOffset() + yDelta;
-        scrollToOffset(newOffsetX, newOffsetY, clamp);
+        IntSize newScrollOffset = scrollOffset() + delta;
+        scrollToOffset(newScrollOffset, clamp);
 
         // If this layer can't do the scroll we ask the next layer up that can scroll to try
-        int leftToScrollX = newOffsetX - scrollXOffset();
-        int leftToScrollY = newOffsetY - scrollYOffset();
-        if ((leftToScrollX || leftToScrollY) && renderer()->parent()) {
+        IntSize remainingScrollOffset = newScrollOffset - scrollOffset();
+        if (!remainingScrollOffset.isZero() && renderer()->parent()) {
             if (RenderLayer* scrollableLayer = enclosingScrollableLayer())
-                scrollableLayer->scrollByRecursively(leftToScrollX, leftToScrollY);
+                scrollableLayer->scrollByRecursively(remainingScrollOffset);
 
             Frame* frame = renderer()->frame();
             if (frame)
@@ -1575,29 +1577,30 @@ void RenderLayer::scrollByRecursively(int xDelta, int yDelta, ScrollOffsetClampi
     } else if (renderer()->view()->frameView()) {
         // If we are here, we were called on a renderer that can be programmatically scrolled, but doesn't
         // have an overflow clip. Which means that it is a document node that can be scrolled.
-        renderer()->view()->frameView()->scrollBy(IntSize(xDelta, yDelta));
+        renderer()->view()->frameView()->scrollBy(delta);
         // FIXME: If we didn't scroll the whole way, do we want to try looking at the frames ownerElement? 
         // https://bugs.webkit.org/show_bug.cgi?id=28237
     }
 }
 
-void RenderLayer::scrollToOffset(int x, int y, ScrollOffsetClamping clamp)
+IntSize RenderLayer::clampScrollOffset(const IntSize& scrollOffset) const
 {
-    if (clamp == ScrollOffsetClamped) {
-        RenderBox* box = renderBox();
-        if (!box)
-            return;
+    RenderBox* box = renderBox();
+    ASSERT(box);
 
-        int maxX = scrollWidth() - box->clientWidth();
-        int maxY = scrollHeight() - box->clientHeight();
+    int maxX = scrollWidth() - box->clientWidth();
+    int maxY = scrollHeight() - box->clientHeight();
 
-        x = min(max(x, 0), maxX);
-        y = min(max(y, 0), maxY);
-    }
+    int x = min(max(scrollOffset.width(), 0), maxX);
+    int y = min(max(scrollOffset.height(), 0), maxY);
+    return IntSize(x, y);
+}
 
-    IntPoint newScrollOffset(x, y);
-    if (newScrollOffset != LayoutPoint(scrollXOffset(), scrollYOffset()))
-        scrollToOffsetWithoutAnimation(newScrollOffset);
+void RenderLayer::scrollToOffset(const IntSize& scrollOffset, ScrollOffsetClamping clamp)
+{
+    IntSize newScrollOffset = clamp == ScrollOffsetClamped ? clampScrollOffset(scrollOffset) : scrollOffset;
+    if (newScrollOffset != this->scrollOffset())
+        scrollToOffsetWithoutAnimation(toPoint(newScrollOffset));
 }
 
 void RenderLayer::scrollTo(int x, int y)
@@ -1692,23 +1695,14 @@ void RenderLayer::scrollRectToVisible(const LayoutRect& rect, const ScrollAlignm
         LayoutRect exposeRect = LayoutRect(rect.x() + scrollXOffset(), rect.y() + scrollYOffset(), rect.width(), rect.height());
         LayoutRect r = getRectToExpose(layerBounds, exposeRect, alignX, alignY);
         
-        LayoutUnit adjustedX = r.x() - absPos.x();
-        LayoutUnit adjustedY = r.y() - absPos.y();
-        // Adjust offsets if they're outside of the allowable range.
-        adjustedX = max<LayoutUnit>(0, min(scrollWidth() - layerBounds.width(), adjustedX));
-        adjustedY = max<LayoutUnit>(0, min(scrollHeight() - layerBounds.height(), adjustedY));
-
-        int xOffset = roundToInt(adjustedX);
-        int yOffset = roundToInt(adjustedY);
-        
-        if (xOffset != scrollXOffset() || yOffset != scrollYOffset()) {
-            int diffX = scrollXOffset();
-            int diffY = scrollYOffset();
-            scrollToOffset(xOffset, yOffset);
-            diffX = scrollXOffset() - diffX;
-            diffY = scrollYOffset() - diffY;
-            newRect.setX(rect.x() - diffX);
-            newRect.setY(rect.y() - diffY);
+        int roundedAdjustedX = roundToInt(r.x() - absPos.x());
+        int roundedAdjustedY = roundToInt(r.y() - absPos.y());
+        IntSize clampedScrollOffset = clampScrollOffset(IntSize(roundedAdjustedX, roundedAdjustedY));
+        if (clampedScrollOffset != scrollOffset()) {
+            IntSize oldScrollOffset = scrollOffset();
+            scrollToOffset(clampedScrollOffset);
+            IntSize scrollOffsetDifference = scrollOffset() - oldScrollOffset;
+            newRect.move(-scrollOffsetDifference);
         }
     } else if (!parentLayer && renderer()->isBox() && renderBox()->canBeProgramaticallyScrolled()) {
         if (frameView) {
@@ -2561,23 +2555,22 @@ void RenderLayer::updateScrollInfoAfterLayout()
         return;
 
     m_scrollDimensionsDirty = true;
-    IntSize scrollOffsetOriginal(scrollXOffset(), scrollYOffset());
+    IntSize originalScrollOffset = scrollOffset();
 
     computeScrollDimensions();
 
     if (box->style()->overflowX() != OMARQUEE) {
         // Layout may cause us to be at an invalid scroll position. In this case we need
         // to pull our scroll offsets back to the max (or push them up to the min).
-        int newX = max(0, min<int>(scrollXOffset(), scrollWidth() - box->clientWidth()));
-        int newY = max(0, min<int>(scrollYOffset(), scrollHeight() - box->clientHeight()));
-        if (newX != scrollXOffset() || newY != scrollYOffset())
-            scrollToOffset(newX, newY);
+        IntSize clampedScrollOffset = clampScrollOffset(scrollOffset());
+        if (clampedScrollOffset != scrollOffset())
+            scrollToOffset(clampedScrollOffset);
     }
 
     updateScrollbarsAfterLayout();
 
-    if (scrollOffsetOriginal != scrollOffset())
-        scrollToOffsetWithoutAnimation(IntPoint(scrollXOffset(), scrollYOffset()));
+    if (originalScrollOffset != scrollOffset())
+        scrollToOffsetWithoutAnimation(toPoint(scrollOffset()));
 }
 
 void RenderLayer::paintOverflowControls(GraphicsContext* context, const IntPoint& paintOffset, const IntRect& damageRect, bool paintingOverlayControls)
index 715fa55cdce40bf66ff76257137c01a8ea04f2a2..599c51714503fe8f53efce3d246ef79bef433707 100644 (file)
@@ -309,7 +309,7 @@ public:
     int scrollWidth() const;
     int scrollHeight() const;
 
-    void panScrollFromPoint(const LayoutPoint&);
+    void panScrollFromPoint(const IntPoint&);
 
     enum ScrollOffsetClamping {
         ScrollOffsetUnclamped,
@@ -317,16 +317,15 @@ public:
     };
 
     // Scrolling methods for layers that can scroll their overflow.
-    void scrollByRecursively(int xDelta, int yDelta, ScrollOffsetClamping = ScrollOffsetUnclamped);
+    void scrollByRecursively(const IntSize&, ScrollOffsetClamping = ScrollOffsetUnclamped);
+    void scrollToOffset(const IntSize&, ScrollOffsetClamping = ScrollOffsetUnclamped);
+    void scrollToXOffset(int x, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(IntSize(x, scrollYOffset()), clamp); }
+    void scrollToYOffset(int y, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(IntSize(scrollXOffset(), y), clamp); }
 
     int scrollXOffset() const { return m_scrollOffset.width() + scrollOrigin().x(); }
     int scrollYOffset() const { return m_scrollOffset.height() + scrollOrigin().y(); }
     IntSize scrollOffset() const { return IntSize(scrollXOffset(), scrollYOffset()); }
 
-    void scrollToOffset(int, int, ScrollOffsetClamping = ScrollOffsetUnclamped);
-    void scrollToXOffset(int x, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(x, scrollYOffset(), clamp); }
-    void scrollToYOffset(int y, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(scrollXOffset(), y, clamp); }
-
     void scrollRectToVisible(const LayoutRect&, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
 
     LayoutRect getRectToExpose(const LayoutRect& visibleRect, const LayoutRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
@@ -678,6 +677,8 @@ private:
     friend IntSize RenderBox::scrolledContentOffset() const;
     IntSize scrolledContentOffset() const { return m_scrollOffset; }
 
+    IntSize clampScrollOffset(const IntSize&) const;
+
     // The normal operator new is disallowed on all render objects.
     void* operator new(size_t) throw();
 
index 2ddffc56f1df25f616247e367078134a81d9bddb..0dc0eed39f76d5abeb80fc2fc5b868560408c3cb 100644 (file)
@@ -167,9 +167,9 @@ void RenderMarquee::start()
 
     if (!m_suspended && !m_stopped) {
         if (isHorizontal())
-            m_layer->scrollToOffset(m_start, 0);
+            m_layer->scrollToOffset(IntSize(m_start, 0));
         else
-            m_layer->scrollToOffset(0, m_start);
+            m_layer->scrollToOffset(IntSize(0, m_start));
     }
     else {
         m_suspended = false;
index d8ad4778f15515fb0b17e00c034727424eaa8e8c..aefbfb46637db0a107dd5b6b9ecad308a4319675 100644 (file)
@@ -4344,7 +4344,7 @@ bool WebPagePrivate::scrollRenderer(RenderObject* renderer, const IntSize& delta
         if (!layerDelta.isZero()) {
             m_inRegionScrollStartingNode = enclosingLayerNode(layer);
             IntPoint newOffset = currentOffset + layerDelta;
-            layer->scrollToOffset(newOffset.x(), newOffset.y());
+            layer->scrollToOffset(toSize(newOffset));
             renderer->repaint(true);
             return true;
         }
index 3dd869ce7dd7c0ad71d2975f93136e45b661f0f4..e86838da5972ea3f7e4e0c1b46e76367dfc4959a 100644 (file)
@@ -1,3 +1,14 @@
+2012-06-20  Julien Chaffraix  <jchaffraix@webkit.org>
+
+        Use IntSize in RenderLayer to represent scroll offsets
+        https://bugs.webkit.org/show_bug.cgi?id=89154
+
+        Reviewed by Eric Seidel.
+
+        * Api/WebPage.cpp:
+        (BlackBerry::WebKit::WebPagePrivate::scrollRenderer):
+        Updated to pass an IntSize to scrollToOffset.
+
 2012-06-19  Yong Li  <yoli@rim.com>
 
         [BlackBerry] Should check the return value of fromUTF8() before executing the script.
index bbbdb75b5b406bc91bd359a9b8f60c03e343ea20..9e27e7a0d51c29898d2ac308c87314f89f243b4f 100644 (file)
@@ -1,3 +1,14 @@
+2012-06-20  Julien Chaffraix  <jchaffraix@webkit.org>
+
+        Use IntSize in RenderLayer to represent scroll offsets
+        https://bugs.webkit.org/show_bug.cgi?id=89154
+
+        Reviewed by Eric Seidel.
+
+        * WebView.cpp:
+        (WebView::gesture):
+        Updated to pass an IntSize to scrollByRecursively.
+
 2012-06-11  Kaustubh Atrawalkar  <kaustubh@motorola.com>
 
         [DRT] LTC:: counterValueForElementById() could be moved to Internals.
index cc2df329b7d3a974c8087feb01feb742b33c82b1..214e35ff2336e28602ce76b43c0cae8063af8a7b 100644 (file)
@@ -1652,7 +1652,7 @@ bool WebView::gesture(WPARAM wParam, LPARAM lParam)
             return false;
 
         // We negate here since panning up moves the content up, but moves the scrollbar down.
-        m_gestureTargetNode->renderer()->enclosingLayer()->scrollByRecursively(-deltaX, -deltaY);
+        m_gestureTargetNode->renderer()->enclosingLayer()->scrollByRecursively(IntSize(-deltaX, -deltaY));
            
         if (!(UpdatePanningFeedbackPtr() && BeginPanningFeedbackPtr() && EndPanningFeedbackPtr())) {
             CloseGestureInfoHandlePtr()(gestureHandle);
index 35cbf6f1d0f35d7442c5dcd786570b41bbf323af..c74a90f4c8e507e3786e13bd8499fc8e82a6902d 100644 (file)
@@ -1,3 +1,14 @@
+2012-06-20  Julien Chaffraix  <jchaffraix@webkit.org>
+
+        Use IntSize in RenderLayer to represent scroll offsets
+        https://bugs.webkit.org/show_bug.cgi?id=89154
+
+        Reviewed by Eric Seidel.
+
+        * WebProcess/WebPage/win/WebPageWin.cpp:
+        (WebKit::WebPage::gestureDidScroll):
+        Updated to pass an IntSize to scrollByRecursively.
+
 2012-06-20  Christophe Dumez  <christophe.dumez@intel.com>
 
         [WK2] Implement Web Intent delivery
index 19f760f6a431001b62f9920818a6f356bd3f43c5..6294f00d88dda04be524107c6bf659bc9e730bc4 100644 (file)
@@ -447,7 +447,7 @@ void WebPage::gestureDidScroll(const IntSize& size)
             verticalScrollbar = view->verticalScrollbar();
     }
 
-    m_gestureTargetNode->renderer()->enclosingLayer()->scrollByRecursively(size.width(), size.height());
+    m_gestureTargetNode->renderer()->enclosingLayer()->scrollByRecursively(size);
     bool gestureReachedScrollingLimit = verticalScrollbar && scrollbarAtTopOrBottomOfDocument(verticalScrollbar);
 
     // FIXME: We really only want to update this state if the state was updated via scrolling the main frame,