Make it possible to test rubber-banding in overflow scroll
authorsimon.fraser@apple.com <simon.fraser@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 31 Oct 2017 23:26:52 +0000 (23:26 +0000)
committersimon.fraser@apple.com <simon.fraser@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 31 Oct 2017 23:26:52 +0000 (23:26 +0000)
https://bugs.webkit.org/show_bug.cgi?id=179078

Reviewed by Sam Weinig.

Source/WebCore:

Test: fast/scrolling/unconstrained-scrollto.html

Add internals.unconstrainedScrollTo(element, x, y) and plumb through ScrollClamping
(which replaces RenderLayer::ScrollOffsetClamping) to support it.

Flip the default from unclamped to clamped for various RenderLayer scrolling-related
functions, since most callers want clamped.

* accessibility/AccessibilityRenderObject.cpp:
(WebCore::AccessibilityRenderObject::scrollTo const):
* dom/Element.cpp:
(WebCore::Element::scrollTo):
* dom/Element.h:
* html/HTMLBodyElement.cpp:
(WebCore::HTMLBodyElement::scrollTo):
* html/HTMLBodyElement.h:
* html/TextFieldInputType.cpp:
(WebCore::TextFieldInputType::elementDidBlur):
* page/DOMWindow.cpp:
(WebCore::DOMWindow::scrollTo const):
* page/DOMWindow.h:
* page/Frame.cpp:
(WebCore::Frame::scrollOverflowLayer):
(WebCore::Frame::checkOverflowScroll):
* platform/ScrollAnimator.cpp:
(WebCore::ScrollAnimator::scrollToOffsetWithoutAnimation):
* platform/ScrollAnimator.h:
* platform/ScrollTypes.h:
* platform/ScrollableArea.cpp:
(WebCore::ScrollableArea::scrollToOffsetWithoutAnimation):
* platform/ScrollableArea.h:
* platform/cocoa/ScrollController.h:
* platform/mac/ScrollAnimatorMac.h:
* platform/mac/ScrollAnimatorMac.mm:
(WebCore::ScrollAnimatorMac::scrollToOffsetWithoutAnimation):
(WebCore::ScrollAnimatorMac::immediateScrollToPosition):
* platform/mock/ScrollAnimatorMock.h:
* rendering/RenderBox.cpp:
(WebCore::RenderBox::setScrollLeft):
(WebCore::RenderBox::setScrollTop):
* rendering/RenderBox.h:
* rendering/RenderLayer.cpp:
(WebCore::RenderLayer::panScrollFromPoint):
(WebCore::RenderLayer::scrollByRecursively):
(WebCore::RenderLayer::applyPostLayoutScrollPositionIfNeeded):
(WebCore::RenderLayer::scrollToXPosition):
(WebCore::RenderLayer::scrollToYPosition):
(WebCore::RenderLayer::scrollToOffset):
* rendering/RenderLayer.h:
* rendering/RenderListBox.cpp:
(WebCore::RenderListBox::setScrollLeft):
(WebCore::RenderListBox::setScrollTop):
* rendering/RenderListBox.h:
* rendering/RenderTextControlSingleLine.cpp:
(WebCore::RenderTextControlSingleLine::setScrollLeft):
(WebCore::RenderTextControlSingleLine::setScrollTop):
* rendering/RenderTextControlSingleLine.h:
* testing/Internals.cpp:
(WebCore::Internals::unconstrainedScrollTo):
* testing/Internals.h:
* testing/Internals.idl:

Source/WebKitLegacy/mac:

Add internals.unconstrainedScrollTo(element, x, y) and plumb through ScrollClamping
(which replaces RenderLayer::ScrollOffsetClamping) to support it.

Flip the default from unclamped to clamped for various RenderLayer scrolling-related
functions, since most callers want clamped.

* DOM/DOMHTML.mm:
(-[DOMHTMLElement setScrollXOffset:scrollYOffset:adjustForIOSCaret:]):

LayoutTests:

Test that internals.unconstrainedScrollTo() works.

* fast/scrolling/unconstrained-scrollto-expected.txt: Added.
* fast/scrolling/unconstrained-scrollto.html: Added.

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

39 files changed:
LayoutTests/ChangeLog
LayoutTests/fast/scrolling/unconstrained-scrollto-expected.txt [new file with mode: 0644]
LayoutTests/fast/scrolling/unconstrained-scrollto.html [new file with mode: 0644]
Source/WebCore/ChangeLog
Source/WebCore/accessibility/AccessibilityRenderObject.cpp
Source/WebCore/dom/Element.cpp
Source/WebCore/dom/Element.h
Source/WebCore/html/HTMLBodyElement.cpp
Source/WebCore/html/HTMLBodyElement.h
Source/WebCore/html/TextFieldInputType.cpp
Source/WebCore/page/DOMWindow.cpp
Source/WebCore/page/DOMWindow.h
Source/WebCore/page/Frame.cpp
Source/WebCore/platform/ScrollAnimator.cpp
Source/WebCore/platform/ScrollAnimator.h
Source/WebCore/platform/ScrollTypes.h
Source/WebCore/platform/ScrollableArea.cpp
Source/WebCore/platform/ScrollableArea.h
Source/WebCore/platform/cocoa/ScrollController.h
Source/WebCore/platform/gtk/ScrollAnimatorGtk.cpp
Source/WebCore/platform/gtk/ScrollAnimatorGtk.h
Source/WebCore/platform/mac/ScrollAnimatorMac.h
Source/WebCore/platform/mac/ScrollAnimatorMac.mm
Source/WebCore/platform/mock/ScrollAnimatorMock.h
Source/WebCore/rendering/RenderBox.cpp
Source/WebCore/rendering/RenderBox.h
Source/WebCore/rendering/RenderLayer.cpp
Source/WebCore/rendering/RenderLayer.h
Source/WebCore/rendering/RenderListBox.cpp
Source/WebCore/rendering/RenderListBox.h
Source/WebCore/rendering/RenderMarquee.cpp
Source/WebCore/rendering/RenderMarquee.h
Source/WebCore/rendering/RenderTextControlSingleLine.cpp
Source/WebCore/rendering/RenderTextControlSingleLine.h
Source/WebCore/testing/Internals.cpp
Source/WebCore/testing/Internals.h
Source/WebCore/testing/Internals.idl
Source/WebKitLegacy/mac/ChangeLog
Source/WebKitLegacy/mac/DOM/DOMHTML.mm

index b244494..a590921 100644 (file)
@@ -1,3 +1,15 @@
+2017-10-31  Simon Fraser  <simon.fraser@apple.com>
+
+        Make it possible to test rubber-banding in overflow scroll
+        https://bugs.webkit.org/show_bug.cgi?id=179078
+
+        Reviewed by Sam Weinig.
+
+        Test that internals.unconstrainedScrollTo() works.
+
+        * fast/scrolling/unconstrained-scrollto-expected.txt: Added.
+        * fast/scrolling/unconstrained-scrollto.html: Added.
+
 2017-10-31  Youenn Fablet  <youenn@apple.com>
 
         rwt should allow service worker to load localhost HTTPS resources with any certificate
 2017-10-31  Youenn Fablet  <youenn@apple.com>
 
         rwt should allow service worker to load localhost HTTPS resources with any certificate
diff --git a/LayoutTests/fast/scrolling/unconstrained-scrollto-expected.txt b/LayoutTests/fast/scrolling/unconstrained-scrollto-expected.txt
new file mode 100644 (file)
index 0000000..d764a90
--- /dev/null
@@ -0,0 +1,5 @@
+PASS scroller.scrollTop is -150
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
diff --git a/LayoutTests/fast/scrolling/unconstrained-scrollto.html b/LayoutTests/fast/scrolling/unconstrained-scrollto.html
new file mode 100644 (file)
index 0000000..c0ccf79
--- /dev/null
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+
+<html>
+<head>
+    <script src="../../resources/js-test-pre.js"></script>
+    <style>
+        #scroller {
+            height: 300px;
+            width: 300px;
+            background-color: green;
+            overflow-y: scroll;
+        }
+        
+        .contents {
+            width: 100%;
+            height: 200%;
+            background-color: silver;
+        }
+    </style>
+    <script>
+        var jsTestIsAsync = true;
+
+        var scroller;
+        function doTest()
+        {
+            scroller = document.getElementById('scroller');
+            if (window.internals)
+                internals.unconstrainedScrollTo(scroller, 0, -150);
+
+            shouldBe('scroller.scrollTop', '-150');
+            finishJSTest();
+        }
+        
+        window.addEventListener('load', doTest, false);
+    </script>
+</head>
+<body>
+
+<div id="scroller">
+    <div class="contents"></div>
+</div>
+<script src="../../resources/js-test-post.js"></script>
+</body>
+</html>
index 305072f..d9a15cd 100644 (file)
@@ -1,3 +1,72 @@
+2017-10-31  Simon Fraser  <simon.fraser@apple.com>
+
+        Make it possible to test rubber-banding in overflow scroll
+        https://bugs.webkit.org/show_bug.cgi?id=179078
+
+        Reviewed by Sam Weinig.
+
+        Test: fast/scrolling/unconstrained-scrollto.html
+        
+        Add internals.unconstrainedScrollTo(element, x, y) and plumb through ScrollClamping
+        (which replaces RenderLayer::ScrollOffsetClamping) to support it.
+
+        Flip the default from unclamped to clamped for various RenderLayer scrolling-related
+        functions, since most callers want clamped.
+
+        * accessibility/AccessibilityRenderObject.cpp:
+        (WebCore::AccessibilityRenderObject::scrollTo const):
+        * dom/Element.cpp:
+        (WebCore::Element::scrollTo):
+        * dom/Element.h:
+        * html/HTMLBodyElement.cpp:
+        (WebCore::HTMLBodyElement::scrollTo):
+        * html/HTMLBodyElement.h:
+        * html/TextFieldInputType.cpp:
+        (WebCore::TextFieldInputType::elementDidBlur):
+        * page/DOMWindow.cpp:
+        (WebCore::DOMWindow::scrollTo const):
+        * page/DOMWindow.h:
+        * page/Frame.cpp:
+        (WebCore::Frame::scrollOverflowLayer):
+        (WebCore::Frame::checkOverflowScroll):
+        * platform/ScrollAnimator.cpp:
+        (WebCore::ScrollAnimator::scrollToOffsetWithoutAnimation):
+        * platform/ScrollAnimator.h:
+        * platform/ScrollTypes.h:
+        * platform/ScrollableArea.cpp:
+        (WebCore::ScrollableArea::scrollToOffsetWithoutAnimation):
+        * platform/ScrollableArea.h:
+        * platform/cocoa/ScrollController.h:
+        * platform/mac/ScrollAnimatorMac.h:
+        * platform/mac/ScrollAnimatorMac.mm:
+        (WebCore::ScrollAnimatorMac::scrollToOffsetWithoutAnimation):
+        (WebCore::ScrollAnimatorMac::immediateScrollToPosition):
+        * platform/mock/ScrollAnimatorMock.h:
+        * rendering/RenderBox.cpp:
+        (WebCore::RenderBox::setScrollLeft):
+        (WebCore::RenderBox::setScrollTop):
+        * rendering/RenderBox.h:
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::panScrollFromPoint):
+        (WebCore::RenderLayer::scrollByRecursively):
+        (WebCore::RenderLayer::applyPostLayoutScrollPositionIfNeeded):
+        (WebCore::RenderLayer::scrollToXPosition):
+        (WebCore::RenderLayer::scrollToYPosition):
+        (WebCore::RenderLayer::scrollToOffset):
+        * rendering/RenderLayer.h:
+        * rendering/RenderListBox.cpp:
+        (WebCore::RenderListBox::setScrollLeft):
+        (WebCore::RenderListBox::setScrollTop):
+        * rendering/RenderListBox.h:
+        * rendering/RenderTextControlSingleLine.cpp:
+        (WebCore::RenderTextControlSingleLine::setScrollLeft):
+        (WebCore::RenderTextControlSingleLine::setScrollTop):
+        * rendering/RenderTextControlSingleLine.h:
+        * testing/Internals.cpp:
+        (WebCore::Internals::unconstrainedScrollTo):
+        * testing/Internals.h:
+        * testing/Internals.idl:
+
 2017-10-31  Dean Jackson  <dino@apple.com>
 
         Accept Settings object in ImageBitmapRenderingContext constructor and getContext
 2017-10-31  Dean Jackson  <dino@apple.com>
 
         Accept Settings object in ImageBitmapRenderingContext constructor and getContext
index acd22e1..6159ee3 100644 (file)
@@ -3722,7 +3722,7 @@ void AccessibilityRenderObject::scrollTo(const IntPoint& point) const
         return;
 
     // FIXME: is point a ScrollOffset or ScrollPosition? Test in RTL overflow.
         return;
 
     // FIXME: is point a ScrollOffset or ScrollPosition? Test in RTL overflow.
-    box.layer()->scrollToOffset(point, RenderLayer::ScrollOffsetClamped);
+    box.layer()->scrollToOffset(point);
 }
 
 #if ENABLE(MATHML)
 }
 
 #if ENABLE(MATHML)
index ad56027..e25152f 100644 (file)
@@ -703,7 +703,7 @@ void Element::scrollBy(double x, double y)
     scrollTo(scrollLeft() + normalizeNonFiniteValue(x), scrollTop() + normalizeNonFiniteValue(y));
 }
 
     scrollTo(scrollLeft() + normalizeNonFiniteValue(x), scrollTop() + normalizeNonFiniteValue(y));
 }
 
-void Element::scrollTo(const ScrollToOptions& options)
+void Element::scrollTo(const ScrollToOptions& options, ScrollClamping clamping)
 {
     // If the element is the root element and document is in quirks mode, terminate these steps.
     // Note that WebKit always uses quirks mode document scrolling behavior. See Document::scrollingElement().
 {
     // If the element is the root element and document is in quirks mode, terminate these steps.
     // Note that WebKit always uses quirks mode document scrolling behavior. See Document::scrollingElement().
@@ -722,8 +722,8 @@ void Element::scrollTo(const ScrollToOptions& options)
     double x = options.left ? normalizeNonFiniteValue(options.left.value()) : adjustForAbsoluteZoom(renderer->scrollLeft(), *renderer);
     double y = options.top ? normalizeNonFiniteValue(options.top.value()) : adjustForAbsoluteZoom(renderer->scrollTop(), *renderer);
 
     double x = options.left ? normalizeNonFiniteValue(options.left.value()) : adjustForAbsoluteZoom(renderer->scrollLeft(), *renderer);
     double y = options.top ? normalizeNonFiniteValue(options.top.value()) : adjustForAbsoluteZoom(renderer->scrollTop(), *renderer);
 
-    renderer->setScrollLeft(clampToInteger(x * renderer->style().effectiveZoom()));
-    renderer->setScrollTop(clampToInteger(y * renderer->style().effectiveZoom()));
+    renderer->setScrollLeft(clampToInteger(x * renderer->style().effectiveZoom()), clamping);
+    renderer->setScrollTop(clampToInteger(y * renderer->style().effectiveZoom()), clamping);
 }
 
 void Element::scrollTo(double x, double y)
 }
 
 void Element::scrollTo(double x, double y)
index 91750cf..b06f19b 100644 (file)
@@ -137,7 +137,7 @@ public:
 
     void scrollBy(const ScrollToOptions&);
     void scrollBy(double x, double y);
 
     void scrollBy(const ScrollToOptions&);
     void scrollBy(double x, double y);
-    virtual void scrollTo(const ScrollToOptions&);
+    virtual void scrollTo(const ScrollToOptions&, ScrollClamping = ScrollClamping::Clamped);
     void scrollTo(double x, double y);
 
     WEBCORE_EXPORT void scrollByLines(int lines);
     void scrollTo(double x, double y);
 
     WEBCORE_EXPORT void scrollByLines(int lines);
index 2ee51ec..db8f328 100644 (file)
@@ -299,7 +299,7 @@ void HTMLBodyElement::setScrollTop(int scrollTop)
     return HTMLElement::setScrollTop(scrollTop);
 }
 
     return HTMLElement::setScrollTop(scrollTop);
 }
 
-void HTMLBodyElement::scrollTo(const ScrollToOptions& options)
+void HTMLBodyElement::scrollTo(const ScrollToOptions& options, ScrollClamping clamping)
 {
     if (isFirstBodyElementOfDocument()) {
         // If the element is the HTML body element, document is in quirks mode, and the element is not potentially scrollable,
 {
     if (isFirstBodyElementOfDocument()) {
         // If the element is the HTML body element, document is in quirks mode, and the element is not potentially scrollable,
@@ -313,7 +313,7 @@ void HTMLBodyElement::scrollTo(const ScrollToOptions& options)
         window->scrollTo(options);
         return;
     }
         window->scrollTo(options);
         return;
     }
-    return HTMLElement::scrollTo(options);
+    return HTMLElement::scrollTo(options, clamping);
 }
 
 int HTMLBodyElement::scrollHeight()
 }
 
 int HTMLBodyElement::scrollHeight()
index 4965fe2..c9cc397 100644 (file)
@@ -57,7 +57,7 @@ private:
     int scrollTop() final;
     void setScrollTop(int) final;
 
     int scrollTop() final;
     void setScrollTop(int) final;
 
-    void scrollTo(const ScrollToOptions&) final;
+    void scrollTo(const ScrollToOptions&, ScrollClamping) final;
     
     int scrollHeight() final;
     int scrollWidth() final;
     
     int scrollHeight() final;
     int scrollWidth() final;
index c55a6bb..c41674d 100644 (file)
@@ -212,7 +212,7 @@ void TextFieldInputType::elementDidBlur()
 
     bool isLeftToRightDirection = downcast<RenderTextControlSingleLine>(*renderer).style().isLeftToRightDirection();
     ScrollOffset scrollOffset(isLeftToRightDirection ? 0 : innerLayer->scrollWidth(), 0);
 
     bool isLeftToRightDirection = downcast<RenderTextControlSingleLine>(*renderer).style().isLeftToRightDirection();
     ScrollOffset scrollOffset(isLeftToRightDirection ? 0 : innerLayer->scrollWidth(), 0);
-    innerLayer->scrollToOffset(scrollOffset, RenderLayer::ScrollOffsetClamped);
+    innerLayer->scrollToOffset(scrollOffset);
 }
 
 void TextFieldInputType::handleFocusEvent(Node* oldFocusedNode, FocusDirection)
 }
 
 void TextFieldInputType::handleFocusEvent(Node* oldFocusedNode, FocusDirection)
index dcf057d..77d5800 100644 (file)
@@ -1551,7 +1551,7 @@ void DOMWindow::scrollBy(double x, double y) const
     view->setContentsScrollPosition(view->contentsScrollPosition() + scaledOffset);
 }
 
     view->setContentsScrollPosition(view->contentsScrollPosition() + scaledOffset);
 }
 
-void DOMWindow::scrollTo(const ScrollToOptions& options) const
+void DOMWindow::scrollTo(const ScrollToOptions& options, ScrollClamping clamping) const
 {
     if (!isCurrentlyDisplayedInFrame())
         return;
 {
     if (!isCurrentlyDisplayedInFrame())
         return;
@@ -1562,10 +1562,10 @@ void DOMWindow::scrollTo(const ScrollToOptions& options) const
 
     double x = options.left ? options.left.value() : view->contentsScrollPosition().x();
     double y = options.top ? options.top.value() : view->contentsScrollPosition().y();
 
     double x = options.left ? options.left.value() : view->contentsScrollPosition().x();
     double y = options.top ? options.top.value() : view->contentsScrollPosition().y();
-    return scrollTo(x, y);
+    return scrollTo(x, y, clamping);
 }
 
 }
 
-void DOMWindow::scrollTo(double x, double y) const
+void DOMWindow::scrollTo(double x, double y, ScrollClamping) const
 {
     if (!isCurrentlyDisplayedInFrame())
         return;
 {
     if (!isCurrentlyDisplayedInFrame())
         return;
index 782ee68..1d7b46b 100644 (file)
@@ -33,6 +33,7 @@
 #include "FrameDestructionObserver.h"
 #include "ImageBitmap.h"
 #include "ScrollToOptions.h"
 #include "FrameDestructionObserver.h"
 #include "ImageBitmap.h"
 #include "ScrollToOptions.h"
+#include "ScrollTypes.h"
 #include "Supplementable.h"
 #include <heap/HandleTypes.h>
 #include <wtf/Function.h>
 #include "Supplementable.h"
 #include <heap/HandleTypes.h>
 #include <wtf/Function.h>
@@ -232,8 +233,8 @@ public:
 
     void scrollBy(const ScrollToOptions&) const;
     void scrollBy(double x, double y) const;
 
     void scrollBy(const ScrollToOptions&) const;
     void scrollBy(double x, double y) const;
-    void scrollTo(const ScrollToOptions&) const;
-    void scrollTo(double x, double y) const;
+    void scrollTo(const ScrollToOptions&, ScrollClamping = ScrollClamping::Clamped) const;
+    void scrollTo(double x, double y, ScrollClamping = ScrollClamping::Clamped) const;
 
     void moveBy(float x, float y) const;
     void moveTo(float x, float y) const;
 
     void moveBy(float x, float y) const;
     void moveTo(float x, float y) const;
index c3be635..3c4d007 100644 (file)
@@ -530,7 +530,7 @@ void Frame::scrollOverflowLayer(RenderLayer* layer, const IntRect& visibleRect,
     else if (exposeBottom >= clientHeight)
         scrollOffset.setY(std::min(box->scrollHeight() - clientHeight, scrollOffset.y() + clientHeight / 2));
 
     else if (exposeBottom >= clientHeight)
         scrollOffset.setY(std::min(box->scrollHeight() - clientHeight, scrollOffset.y() + clientHeight / 2));
 
-    layer->scrollToOffset(scrollOffset);
+    layer->scrollToOffset(scrollOffset, ScrollClamping::Unclamped);
     selection().setCaretRectNeedsUpdate();
     selection().updateAppearance();
 }
     selection().setCaretRectNeedsUpdate();
     selection().updateAppearance();
 }
@@ -626,7 +626,7 @@ int Frame::checkOverflowScroll(OverflowScrollAction action)
     Ref<Frame> protectedThis(*this);
 
     if (action == PerformOverflowScroll && (deltaX || deltaY)) {
     Ref<Frame> protectedThis(*this);
 
     if (action == PerformOverflowScroll && (deltaX || deltaY)) {
-        layer->scrollToOffset(layer->scrollOffset() + IntSize(deltaX, deltaY));
+        layer->scrollToOffset(layer->scrollOffset() + IntSize(deltaX, deltaY), ScrollClamping::Unclamped);
 
         // Handle making selection.
         VisiblePosition visiblePosition(renderer->positionForPoint(selectionPosition, nullptr));
 
         // Handle making selection.
         VisiblePosition visiblePosition(renderer->positionForPoint(selectionPosition, nullptr));
index 411ef64..0db3408 100644 (file)
@@ -75,7 +75,7 @@ bool ScrollAnimator::scroll(ScrollbarOrientation orientation, ScrollGranularity,
     return true;
 }
 
     return true;
 }
 
-void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
+void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping)
 {
     FloatPoint newPositon = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));
     FloatSize delta = newPositon - currentPosition();
 {
     FloatPoint newPositon = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));
     FloatSize delta = newPositon - currentPosition();
index d7c73db..6e2a884 100644 (file)
@@ -29,8 +29,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef ScrollAnimator_h
-#define ScrollAnimator_h
+#pragma once
 
 #include "FloatPoint.h"
 #include "PlatformWheelEvent.h"
 
 #include "FloatPoint.h"
 #include "PlatformWheelEvent.h"
@@ -69,7 +68,7 @@ public:
     // The base class implementation always scrolls immediately, never animates.
     virtual bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier);
 
     // The base class implementation always scrolls immediately, never animates.
     virtual bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier);
 
-    virtual void scrollToOffsetWithoutAnimation(const FloatPoint&);
+    virtual void scrollToOffsetWithoutAnimation(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);
 
     ScrollableArea& scrollableArea() const { return m_scrollableArea; }
 
 
     ScrollableArea& scrollableArea() const { return m_scrollableArea; }
 
@@ -155,4 +154,3 @@ protected:
 
 } // namespace WebCore
 
 
 } // namespace WebCore
 
-#endif // ScrollAnimator_h
index e1a90ec..b928b73 100644 (file)
@@ -177,6 +177,11 @@ enum ScrollPinningBehavior {
     PinToBottom
 };
 
     PinToBottom
 };
 
+enum class ScrollClamping {
+    Unclamped,
+    Clamped
+};
+
 enum ScrollBehaviorForFixedElements {
     StickToDocumentBounds,
     StickToViewportBounds
 enum ScrollBehaviorForFixedElements {
     StickToDocumentBounds,
     StickToViewportBounds
index 65c11e1..46e71ea 100644 (file)
@@ -139,10 +139,10 @@ bool ScrollableArea::scroll(ScrollDirection direction, ScrollGranularity granula
     return scrollAnimator().scroll(orientation, granularity, step, multiplier);
 }
 
     return scrollAnimator().scroll(orientation, granularity, step, multiplier);
 }
 
-void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
+void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping clamping)
 {
     LOG_WITH_STREAM(Scrolling, stream << "ScrollableArea " << this << " scrollToOffsetWithoutAnimation " << offset);
 {
     LOG_WITH_STREAM(Scrolling, stream << "ScrollableArea " << this << " scrollToOffsetWithoutAnimation " << offset);
-    scrollAnimator().scrollToOffsetWithoutAnimation(offset);
+    scrollAnimator().scrollToOffsetWithoutAnimation(offset, clamping);
 }
 
 void ScrollableArea::scrollToOffsetWithoutAnimation(ScrollbarOrientation orientation, float offset)
 }
 
 void ScrollableArea::scrollToOffsetWithoutAnimation(ScrollbarOrientation orientation, float offset)
index 14b6561..3e54463 100644 (file)
@@ -26,6 +26,7 @@
 #pragma once
 
 #include "ScrollSnapOffsetsInfo.h"
 #pragma once
 
 #include "ScrollSnapOffsetsInfo.h"
+#include "ScrollTypes.h"
 #include "Scrollbar.h"
 #include <wtf/Forward.h>
 #include <wtf/WeakPtr.h>
 #include "Scrollbar.h"
 #include <wtf/Forward.h>
 #include <wtf/WeakPtr.h>
@@ -50,7 +51,7 @@ typedef IntPoint ScrollOffset;
 class ScrollableArea {
 public:
     WEBCORE_EXPORT bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
 class ScrollableArea {
 public:
     WEBCORE_EXPORT bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
-    WEBCORE_EXPORT void scrollToOffsetWithoutAnimation(const FloatPoint&);
+    WEBCORE_EXPORT void scrollToOffsetWithoutAnimation(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);
     void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);
 
     // Should be called when the scroll position changes externally, for example if the scroll layer position
     void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);
 
     // Should be called when the scroll position changes externally, for example if the scroll layer position
index b3f74b9..fe35ffa 100644 (file)
@@ -61,6 +61,7 @@ public:
     virtual bool canScrollVertically() = 0;
     virtual bool shouldRubberBandInDirection(ScrollDirection) = 0;
 
     virtual bool canScrollVertically() = 0;
     virtual bool shouldRubberBandInDirection(ScrollDirection) = 0;
 
+    // FIXME: use ScrollClamping to collapse these to one.
     virtual void immediateScrollBy(const FloatSize&) = 0;
     virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) = 0;
     virtual void startSnapRubberbandTimer()
     virtual void immediateScrollBy(const FloatSize&) = 0;
     virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize&) = 0;
     virtual void startSnapRubberbandTimer()
index 8f7ee6f..8151ad6 100644 (file)
@@ -91,7 +91,7 @@ bool ScrollAnimatorGtk::scroll(ScrollbarOrientation orientation, ScrollGranulari
 }
 #endif
 
 }
 #endif
 
-void ScrollAnimatorGtk::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
+void ScrollAnimatorGtk::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping)
 {
     FloatPoint position = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));
     m_kineticAnimation->stop();
 {
     FloatPoint position = ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin()));
     m_kineticAnimation->stop();
index 9614e63..b204703 100644 (file)
@@ -47,7 +47,7 @@ private:
 #if ENABLE(SMOOTH_SCROLLING)
     bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier) override;
 #endif
 #if ENABLE(SMOOTH_SCROLLING)
     bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier) override;
 #endif
-    void scrollToOffsetWithoutAnimation(const FloatPoint&) override;
+    void scrollToOffsetWithoutAnimation(const FloatPoint&, ScrollClamping) override;
     void willEndLiveResize() override;
 
     bool handleWheelEvent(const PlatformWheelEvent&) override;
     void willEndLiveResize() override;
 
     bool handleWheelEvent(const PlatformWheelEvent&) override;
index a9fab7d..ff733c1 100644 (file)
@@ -24,8 +24,7 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef ScrollAnimatorMac_h
-#define ScrollAnimatorMac_h
+#pragma once
 
 #if ENABLE(SMOOTH_SCROLLING)
 
 
 #if ENABLE(SMOOTH_SCROLLING)
 
@@ -82,7 +81,7 @@ private:
     FloatSize m_contentAreaScrolledTimerScrollDelta;
 
     bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier) override;
     FloatSize m_contentAreaScrolledTimerScrollDelta;
 
     bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier) override;
-    void scrollToOffsetWithoutAnimation(const FloatPoint&) override;
+    void scrollToOffsetWithoutAnimation(const FloatPoint&, ScrollClamping) override;
 
 #if ENABLE(RUBBER_BANDING)
     bool shouldForwardWheelEventsToParent(const PlatformWheelEvent&);
 
 #if ENABLE(RUBBER_BANDING)
     bool shouldForwardWheelEventsToParent(const PlatformWheelEvent&);
@@ -134,7 +133,7 @@ private:
 
     FloatPoint adjustScrollPositionIfNecessary(const FloatPoint&) const;
 
 
     FloatPoint adjustScrollPositionIfNecessary(const FloatPoint&) const;
 
-    void immediateScrollToPosition(const FloatPoint&);
+    void immediateScrollToPosition(const FloatPoint&, ScrollClamping = ScrollClamping::Clamped);
 
     bool isRubberBandInProgress() const override;
     bool isScrollSnapInProgress() const override;
 
     bool isRubberBandInProgress() const override;
     bool isScrollSnapInProgress() const override;
@@ -164,4 +163,3 @@ private:
 
 #endif // ENABLE(SMOOTH_SCROLLING)
 
 
 #endif // ENABLE(SMOOTH_SCROLLING)
 
-#endif // ScrollAnimatorMac_h
index 868b192..7972788 100644 (file)
@@ -709,10 +709,10 @@ bool ScrollAnimatorMac::scroll(ScrollbarOrientation orientation, ScrollGranulari
 }
 
 // FIXME: Maybe this should take a position.
 }
 
 // FIXME: Maybe this should take a position.
-void ScrollAnimatorMac::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
+void ScrollAnimatorMac::scrollToOffsetWithoutAnimation(const FloatPoint& offset, ScrollClamping clamping)
 {
     [m_scrollAnimationHelper _stopRun];
 {
     [m_scrollAnimationHelper _stopRun];
-    immediateScrollToPosition(ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin())));
+    immediateScrollToPosition(ScrollableArea::scrollPositionFromOffset(offset, toFloatSize(m_scrollableArea.scrollOrigin())), clamping);
 }
 
 FloatPoint ScrollAnimatorMac::adjustScrollPositionIfNecessary(const FloatPoint& position) const
 }
 
 FloatPoint ScrollAnimatorMac::adjustScrollPositionIfNecessary(const FloatPoint& position) const
@@ -735,10 +735,10 @@ void ScrollAnimatorMac::adjustScrollPositionToBoundsIfNecessary()
     m_scrollableArea.setConstrainsScrollingToContentEdge(currentlyConstrainsToContentEdge);
 }
 
     m_scrollableArea.setConstrainsScrollingToContentEdge(currentlyConstrainsToContentEdge);
 }
 
-void ScrollAnimatorMac::immediateScrollToPosition(const FloatPoint& newPosition)
+void ScrollAnimatorMac::immediateScrollToPosition(const FloatPoint& newPosition, ScrollClamping clamping)
 {
     FloatPoint currentPosition = this->currentPosition();
 {
     FloatPoint currentPosition = this->currentPosition();
-    FloatPoint adjustedPosition = adjustScrollPositionIfNecessary(newPosition);
+    FloatPoint adjustedPosition = clamping == ScrollClamping::Clamped ? adjustScrollPositionIfNecessary(newPosition) : newPosition;
  
     bool positionChanged = adjustedPosition != currentPosition;
     if (!positionChanged && !scrollableArea().scrollOriginChanged())
  
     bool positionChanged = adjustedPosition != currentPosition;
     if (!positionChanged && !scrollableArea().scrollOriginChanged())
index 230b9af..2563213 100644 (file)
@@ -28,8 +28,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef ScrollAnimatorMock_h
-#define ScrollAnimatorMock_h
+#pragma once
 
 #include "ScrollAnimator.h"
 
 
 #include "ScrollAnimator.h"
 
@@ -43,6 +42,8 @@ public:
     ScrollAnimatorMock(ScrollableArea&, WTF::Function<void(const String&)>&&);
     virtual ~ScrollAnimatorMock();
 
     ScrollAnimatorMock(ScrollableArea&, WTF::Function<void(const String&)>&&);
     virtual ~ScrollAnimatorMock();
 
+private:
+
 #if ENABLE(RUBBER_BANDING)
     bool allowsHorizontalStretching(const PlatformWheelEvent&) override { return false; }
     bool allowsVerticalStretching(const PlatformWheelEvent&) override { return false; }
 #if ENABLE(RUBBER_BANDING)
     bool allowsHorizontalStretching(const PlatformWheelEvent&) override { return false; }
     bool allowsVerticalStretching(const PlatformWheelEvent&) override { return false; }
@@ -56,7 +57,6 @@ public:
     void adjustScrollPositionToBoundsIfNecessary() override { }
 #endif
 
     void adjustScrollPositionToBoundsIfNecessary() override { }
 #endif
 
-private:
     void didAddVerticalScrollbar(Scrollbar*) override;
     void didAddHorizontalScrollbar(Scrollbar*) override;
     void willRemoveVerticalScrollbar(Scrollbar*) override;
     void didAddVerticalScrollbar(Scrollbar*) override;
     void didAddHorizontalScrollbar(Scrollbar*) override;
     void willRemoveVerticalScrollbar(Scrollbar*) override;
@@ -75,4 +75,3 @@ private:
 
 } // namespace WebCore
 
 
 } // namespace WebCore
 
-#endif // ScrollAnimatorMock_h
index 5d14f00..60d04b1 100644 (file)
@@ -572,20 +572,20 @@ static void setupWheelEventTestTrigger(RenderLayer& layer)
     layer.scrollAnimator().setWheelEventTestTrigger(page.testTrigger());
 }
 
     layer.scrollAnimator().setWheelEventTestTrigger(page.testTrigger());
 }
 
-void RenderBox::setScrollLeft(int newLeft)
+void RenderBox::setScrollLeft(int newLeft, ScrollClamping clamping)
 {
     if (!hasOverflowClip() || !layer())
         return;
     setupWheelEventTestTrigger(*layer());
 {
     if (!hasOverflowClip() || !layer())
         return;
     setupWheelEventTestTrigger(*layer());
-    layer()->scrollToXPosition(newLeft, RenderLayer::ScrollOffsetClamped);
+    layer()->scrollToXPosition(newLeft, clamping);
 }
 
 }
 
-void RenderBox::setScrollTop(int newTop)
+void RenderBox::setScrollTop(int newTop, ScrollClamping clamping)
 {
     if (!hasOverflowClip() || !layer())
         return;
     setupWheelEventTestTrigger(*layer());
 {
     if (!hasOverflowClip() || !layer())
         return;
     setupWheelEventTestTrigger(*layer());
-    layer()->scrollToYPosition(newTop, RenderLayer::ScrollOffsetClamped);
+    layer()->scrollToYPosition(newTop, clamping);
 }
 
 void RenderBox::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 }
 
 void RenderBox::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
index 77d2fd4..3198ca8 100644 (file)
@@ -240,8 +240,8 @@ public:
     virtual int scrollTop() const;
     virtual int scrollWidth() const;
     virtual int scrollHeight() const;
     virtual int scrollTop() const;
     virtual int scrollWidth() const;
     virtual int scrollHeight() const;
-    virtual void setScrollLeft(int);
-    virtual void setScrollTop(int);
+    virtual void setScrollLeft(int, ScrollClamping = ScrollClamping::Clamped);
+    virtual void setScrollTop(int, ScrollClamping = ScrollClamping::Clamped);
 
     LayoutUnit marginTop() const override { return m_marginBox.top(); }
     LayoutUnit marginBottom() const override { return m_marginBox.bottom(); }
 
     LayoutUnit marginTop() const override { return m_marginBox.top(); }
     LayoutUnit marginBottom() const override { return m_marginBox.bottom(); }
index 458747c..22822f3 100644 (file)
@@ -2270,11 +2270,11 @@ void RenderLayer::panScrollFromPoint(const IntPoint& sourcePoint)
     if (abs(delta.height()) <= ScrollView::noPanScrollRadius)
         delta.setHeight(0);
 
     if (abs(delta.height()) <= ScrollView::noPanScrollRadius)
         delta.setHeight(0);
 
-    scrollByRecursively(adjustedScrollDelta(delta), ScrollOffsetClamped);
+    scrollByRecursively(adjustedScrollDelta(delta));
 }
 
 // FIXME: unify with the scrollRectToVisible() code below.
 }
 
 // FIXME: unify with the scrollRectToVisible() code below.
-void RenderLayer::scrollByRecursively(const IntSize& delta, ScrollOffsetClamping clamp, ScrollableArea** scrolledArea)
+void RenderLayer::scrollByRecursively(const IntSize& delta, ScrollableArea** scrolledArea)
 {
     if (delta.isZero())
         return;
 {
     if (delta.isZero())
         return;
@@ -2285,7 +2285,7 @@ void RenderLayer::scrollByRecursively(const IntSize& delta, ScrollOffsetClamping
 
     if (renderer().hasOverflowClip() && !restrictedByLineClamp) {
         ScrollOffset newScrollOffset = scrollOffset() + delta;
 
     if (renderer().hasOverflowClip() && !restrictedByLineClamp) {
         ScrollOffset newScrollOffset = scrollOffset() + delta;
-        scrollToOffset(newScrollOffset, clamp);
+        scrollToOffset(newScrollOffset);
         if (scrolledArea)
             *scrolledArea = this;
 
         if (scrolledArea)
             *scrolledArea = this;
 
@@ -2293,7 +2293,7 @@ void RenderLayer::scrollByRecursively(const IntSize& delta, ScrollOffsetClamping
         IntSize remainingScrollOffset = newScrollOffset - scrollOffset();
         if (!remainingScrollOffset.isZero() && renderer().parent()) {
             if (RenderLayer* scrollableLayer = enclosingScrollableLayer())
         IntSize remainingScrollOffset = newScrollOffset - scrollOffset();
         if (!remainingScrollOffset.isZero() && renderer().parent()) {
             if (RenderLayer* scrollableLayer = enclosingScrollableLayer())
-                scrollableLayer->scrollByRecursively(remainingScrollOffset, clamp, scrolledArea);
+                scrollableLayer->scrollByRecursively(remainingScrollOffset, scrolledArea);
 
             renderer().frame().eventHandler().updateAutoscrollRenderer();
         }
 
             renderer().frame().eventHandler().updateAutoscrollRenderer();
         }
@@ -2319,20 +2319,20 @@ void RenderLayer::applyPostLayoutScrollPositionIfNeeded()
     if (!m_postLayoutScrollPosition)
         return;
 
     if (!m_postLayoutScrollPosition)
         return;
 
-    scrollToOffset(scrollOffsetFromPosition(m_postLayoutScrollPosition.value()), ScrollOffsetClamped);
+    scrollToOffset(scrollOffsetFromPosition(m_postLayoutScrollPosition.value()));
     m_postLayoutScrollPosition = std::nullopt;
 }
 
     m_postLayoutScrollPosition = std::nullopt;
 }
 
-void RenderLayer::scrollToXPosition(int x, ScrollOffsetClamping clamp)
+void RenderLayer::scrollToXPosition(int x, ScrollClamping clamping)
 {
     ScrollPosition position(x, m_scrollPosition.y());
 {
     ScrollPosition position(x, m_scrollPosition.y());
-    scrollToOffset(scrollOffsetFromPosition(position), clamp);
+    scrollToOffset(scrollOffsetFromPosition(position), clamping);
 }
 
 }
 
-void RenderLayer::scrollToYPosition(int y, ScrollOffsetClamping clamp)
+void RenderLayer::scrollToYPosition(int y, ScrollClamping clamping)
 {
     ScrollPosition position(m_scrollPosition.x(), y);
 {
     ScrollPosition position(m_scrollPosition.x(), y);
-    scrollToOffset(scrollOffsetFromPosition(position), clamp);
+    scrollToOffset(scrollOffsetFromPosition(position), clamping);
 }
 
 ScrollOffset RenderLayer::clampScrollOffset(const ScrollOffset& scrollOffset) const
 }
 
 ScrollOffset RenderLayer::clampScrollOffset(const ScrollOffset& scrollOffset) const
@@ -2340,11 +2340,11 @@ ScrollOffset RenderLayer::clampScrollOffset(const ScrollOffset& scrollOffset) co
     return scrollOffset.constrainedBetween(IntPoint(), maximumScrollOffset());
 }
 
     return scrollOffset.constrainedBetween(IntPoint(), maximumScrollOffset());
 }
 
-void RenderLayer::scrollToOffset(const ScrollOffset& scrollOffset, ScrollOffsetClamping clamp)
+void RenderLayer::scrollToOffset(const ScrollOffset& scrollOffset, ScrollClamping clamping)
 {
 {
-    ScrollOffset newScrollOffset = clamp == ScrollOffsetClamped ? clampScrollOffset(scrollOffset) : scrollOffset;
+    ScrollOffset newScrollOffset = clamping == ScrollClamping::Clamped ? clampScrollOffset(scrollOffset) : scrollOffset;
     if (newScrollOffset != this->scrollOffset())
     if (newScrollOffset != this->scrollOffset())
-        scrollToOffsetWithoutAnimation(newScrollOffset);
+        scrollToOffsetWithoutAnimation(newScrollOffset, clamping);
 }
 
 void RenderLayer::scrollTo(const ScrollPosition& position)
 }
 
 void RenderLayer::scrollTo(const ScrollPosition& position)
index 770636f..d24cdb4 100644 (file)
@@ -197,20 +197,15 @@ public:
 
     void panScrollFromPoint(const IntPoint&);
 
 
     void panScrollFromPoint(const IntPoint&);
 
-    enum ScrollOffsetClamping {
-        ScrollOffsetUnclamped,
-        ScrollOffsetClamped
-    };
-
     // Scrolling methods for layers that can scroll their overflow.
     // Scrolling methods for layers that can scroll their overflow.
-    void scrollByRecursively(const IntSize& delta, ScrollOffsetClamping = ScrollOffsetUnclamped, ScrollableArea** scrolledArea = nullptr);
+    void scrollByRecursively(const IntSize& delta, ScrollableArea** scrolledArea = nullptr);
 
 
-    WEBCORE_EXPORT void scrollToOffset(const ScrollOffset&, ScrollOffsetClamping = ScrollOffsetUnclamped);
-    void scrollToXOffset(int x, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(ScrollOffset(x, scrollOffset().y()), clamp); }
-    void scrollToYOffset(int y, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(ScrollOffset(scrollOffset().x(), y), clamp); }
+    WEBCORE_EXPORT void scrollToOffset(const ScrollOffset&, ScrollClamping = ScrollClamping::Clamped);
+    void scrollToXOffset(int x, ScrollClamping clamping = ScrollClamping::Clamped) { scrollToOffset(ScrollOffset(x, scrollOffset().y()), clamping); }
+    void scrollToYOffset(int y, ScrollClamping clamping = ScrollClamping::Clamped) { scrollToOffset(ScrollOffset(scrollOffset().x(), y), clamping); }
 
 
-    void scrollToXPosition(int x, ScrollOffsetClamping = ScrollOffsetUnclamped);
-    void scrollToYPosition(int y, ScrollOffsetClamping = ScrollOffsetUnclamped);
+    void scrollToXPosition(int x, ScrollClamping = ScrollClamping::Clamped);
+    void scrollToYPosition(int y, ScrollClamping = ScrollClamping::Clamped);
 
     void setPostLayoutScrollPosition(std::optional<ScrollPosition>);
     void applyPostLayoutScrollPositionIfNeeded();
 
     void setPostLayoutScrollPosition(std::optional<ScrollPosition>);
     void applyPostLayoutScrollPositionIfNeeded();
index b11edc6..aed0566 100644 (file)
@@ -734,7 +734,7 @@ int RenderListBox::scrollLeft() const
     return 0;
 }
 
     return 0;
 }
 
-void RenderListBox::setScrollLeft(int)
+void RenderListBox::setScrollLeft(int, ScrollClamping)
 {
 }
 
 {
 }
 
@@ -751,7 +751,7 @@ static void setupWheelEventTestTrigger(RenderListBox& renderer)
     renderer.scrollAnimator().setWheelEventTestTrigger(renderer.page().testTrigger());
 }
 
     renderer.scrollAnimator().setWheelEventTestTrigger(renderer.page().testTrigger());
 }
 
-void RenderListBox::setScrollTop(int newTop)
+void RenderListBox::setScrollTop(int newTop, ScrollClamping)
 {
     // Determine an index and scroll to it.    
     int index = newTop / itemHeight();
 {
     // Determine an index and scroll to it.    
     int index = newTop / itemHeight();
index 24898cd..7f86ec1 100644 (file)
@@ -105,8 +105,8 @@ private:
     int scrollTop() const override;
     int scrollWidth() const override;
     int scrollHeight() const override;
     int scrollTop() const override;
     int scrollWidth() const override;
     int scrollHeight() const override;
-    void setScrollLeft(int) override;
-    void setScrollTop(int) override;
+    void setScrollLeft(int, ScrollClamping) override;
+    void setScrollTop(int, ScrollClamping) override;
 
     bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
 
 
     bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
 
index 0283368..2f59a88 100644 (file)
@@ -57,11 +57,12 @@ namespace WebCore {
 using namespace HTMLNames;
 
 RenderMarquee::RenderMarquee(RenderLayer* l)
 using namespace HTMLNames;
 
 RenderMarquee::RenderMarquee(RenderLayer* l)
-    : m_layer(l), m_currentLoop(0)
-    , m_totalLoops(0)
+    : m_layer(l)
     , m_timer(*this, &RenderMarquee::timerFired)
     , m_timer(*this, &RenderMarquee::timerFired)
-    , m_start(0), m_end(0), m_speed(0), m_reset(false)
-    , m_suspended(false), m_stopped(false), m_direction(MAUTO)
+    , m_reset(false)
+    , m_suspended(false)
+    , m_stopped(false)
+    , m_direction(MAUTO)
 {
     l->setConstrainsScrollingToContentEdge(false);
 }
 {
     l->setConstrainsScrollingToContentEdge(false);
 }
@@ -157,9 +158,9 @@ void RenderMarquee::start()
 
     if (!m_suspended && !m_stopped) {
         if (isHorizontal())
 
     if (!m_suspended && !m_stopped) {
         if (isHorizontal())
-            m_layer->scrollToOffset(ScrollOffset(m_start, 0));
+            m_layer->scrollToOffset(ScrollOffset(m_start, 0), ScrollClamping::Unclamped);
         else
         else
-            m_layer->scrollToOffset(ScrollOffset(0, m_start));
+            m_layer->scrollToOffset(ScrollOffset(0, m_start), ScrollClamping::Unclamped);
     }
     else {
         m_suspended = false;
     }
     else {
         m_suspended = false;
@@ -232,9 +233,9 @@ void RenderMarquee::timerFired()
     if (m_reset) {
         m_reset = false;
         if (isHorizontal())
     if (m_reset) {
         m_reset = false;
         if (isHorizontal())
-            m_layer->scrollToXOffset(m_start);
+            m_layer->scrollToXOffset(m_start, ScrollClamping::Unclamped);
         else
         else
-            m_layer->scrollToYOffset(m_start);
+            m_layer->scrollToYOffset(m_start, ScrollClamping::Unclamped);
         return;
     }
     
         return;
     }
     
@@ -274,9 +275,9 @@ void RenderMarquee::timerFired()
     }
     
     if (isHorizontal())
     }
     
     if (isHorizontal())
-        m_layer->scrollToXOffset(newPos);
+        m_layer->scrollToXOffset(newPos, ScrollClamping::Unclamped);
     else
     else
-        m_layer->scrollToYOffset(newPos);
+        m_layer->scrollToYOffset(newPos, ScrollClamping::Unclamped);
 }
 
 } // namespace WebCore
 }
 
 } // namespace WebCore
index 0636c0c..bcfde14 100644 (file)
@@ -81,12 +81,12 @@ private:
     void timerFired();
 
     RenderLayer* m_layer;
     void timerFired();
 
     RenderLayer* m_layer;
-    int m_currentLoop;
-    int m_totalLoops;
     Timer m_timer;
     Timer m_timer;
-    int m_start;
-    int m_end;
-    int m_speed;
+    int m_currentLoop { 0 };
+    int m_totalLoops { 0 };
+    int m_start { 0 };
+    int m_end { 0 };
+    int m_speed { 0 };
     Length m_height;
     bool m_reset: 1;
     bool m_suspended : 1;
     Length m_height;
     bool m_reset: 1;
     bool m_suspended : 1;
index 6c92c1f..7102252 100644 (file)
@@ -340,13 +340,13 @@ int RenderTextControlSingleLine::scrollTop() const
     return RenderBlockFlow::scrollTop();
 }
 
     return RenderBlockFlow::scrollTop();
 }
 
-void RenderTextControlSingleLine::setScrollLeft(int newLeft)
+void RenderTextControlSingleLine::setScrollLeft(int newLeft, ScrollClamping)
 {
     if (innerTextElement())
         innerTextElement()->setScrollLeft(newLeft);
 }
 
 {
     if (innerTextElement())
         innerTextElement()->setScrollLeft(newLeft);
 }
 
-void RenderTextControlSingleLine::setScrollTop(int newTop)
+void RenderTextControlSingleLine::setScrollTop(int newTop, ScrollClamping)
 {
     if (innerTextElement())
         innerTextElement()->setScrollTop(newTop);
 {
     if (innerTextElement())
         innerTextElement()->setScrollTop(newTop);
index 3b82a71..cba5d60 100644 (file)
@@ -56,8 +56,8 @@ private:
     int scrollTop() const override;
     int scrollWidth() const override;
     int scrollHeight() const override;
     int scrollTop() const override;
     int scrollWidth() const override;
     int scrollHeight() const override;
-    void setScrollLeft(int) override;
-    void setScrollTop(int) override;
+    void setScrollLeft(int, ScrollClamping) override;
+    void setScrollTop(int, ScrollClamping) override;
     bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1, Element** stopElement = nullptr, RenderBox* startBox = nullptr, const IntPoint& wheelEventAbsolutePoint = IntPoint()) final;
     bool logicalScroll(ScrollLogicalDirection, ScrollGranularity, float multiplier = 1, Element** stopElement = 0) final;
 
     bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1, Element** stopElement = nullptr, RenderBox* startBox = nullptr, const IntPoint& wheelEventAbsolutePoint = IntPoint()) final;
     bool logicalScroll(ScrollLogicalDirection, ScrollGranularity, float multiplier = 1, Element** stopElement = 0) final;
 
index 3cd5020..d22c082 100644 (file)
@@ -1510,6 +1510,16 @@ ExceptionOr<void> Internals::setScrollViewPosition(int x, int y)
     return { };
 }
 
     return { };
 }
 
+ExceptionOr<void> Internals::unconstrainedScrollTo(Element& element, double x, double y)
+{
+    Document* document = contextDocument();
+    if (!document || !document->view())
+        return Exception { InvalidAccessError };
+
+    element.scrollTo({ x, y }, ScrollClamping::Unclamped);
+    return { };
+}
+
 ExceptionOr<Ref<DOMRect>> Internals::layoutViewportRect()
 {
     Document* document = contextDocument();
 ExceptionOr<Ref<DOMRect>> Internals::layoutViewportRect()
 {
     Document* document = contextDocument();
index 9ff3f44..611ea2d 100644 (file)
@@ -211,6 +211,7 @@ public:
     ExceptionOr<void> setLowPowerModeEnabled(bool);
 
     ExceptionOr<void> setScrollViewPosition(int x, int y);
     ExceptionOr<void> setLowPowerModeEnabled(bool);
 
     ExceptionOr<void> setScrollViewPosition(int x, int y);
+    ExceptionOr<void> unconstrainedScrollTo(Element&, double x, double y);
 
     ExceptionOr<Ref<DOMRect>> layoutViewportRect();
     ExceptionOr<Ref<DOMRect>> visualViewportRect();
 
     ExceptionOr<Ref<DOMRect>> layoutViewportRect();
     ExceptionOr<Ref<DOMRect>> visualViewportRect();
index 0c17fa9..f176bdc 100644 (file)
@@ -167,6 +167,9 @@ enum EventThrottlingBehavior {
 
     [MayThrowException] void setScrollViewPosition(long x, long y);
 
 
     [MayThrowException] void setScrollViewPosition(long x, long y);
 
+    // Like Element.scrollTo(), but without constaints, for testing rubber-banding.
+    [MayThrowException] void unconstrainedScrollTo(Element element, unrestricted double x, unrestricted double y);
+
     [MayThrowException] DOMRect layoutViewportRect();
     [MayThrowException] DOMRect visualViewportRect();
 
     [MayThrowException] DOMRect layoutViewportRect();
     [MayThrowException] DOMRect visualViewportRect();
 
index 250c624..e3009de 100644 (file)
@@ -1,3 +1,19 @@
+2017-10-31  Simon Fraser  <simon.fraser@apple.com>
+
+        Make it possible to test rubber-banding in overflow scroll
+        https://bugs.webkit.org/show_bug.cgi?id=179078
+
+        Reviewed by Sam Weinig.
+
+        Add internals.unconstrainedScrollTo(element, x, y) and plumb through ScrollClamping
+        (which replaces RenderLayer::ScrollOffsetClamping) to support it.
+
+        Flip the default from unclamped to clamped for various RenderLayer scrolling-related
+        functions, since most callers want clamped.
+
+        * DOM/DOMHTML.mm:
+        (-[DOMHTMLElement setScrollXOffset:scrollYOffset:adjustForIOSCaret:]):
+
 2017-10-31  Tim Horton  <timothy_horton@apple.com>
 
         Fix up some content filtering feature flags
 2017-10-31  Tim Horton  <timothy_horton@apple.com>
 
         Fix up some content filtering feature flags
index 72d68b8..7a5f981 100644 (file)
@@ -115,7 +115,7 @@ using namespace WebCore;
     RenderLayer* layer = downcast<RenderBox>(*renderer).layer();
     if (adjustForIOSCaret)
         layer->setAdjustForIOSCaretWhenScrolling(true);
     RenderLayer* layer = downcast<RenderBox>(*renderer).layer();
     if (adjustForIOSCaret)
         layer->setAdjustForIOSCaretWhenScrolling(true);
-    layer->scrollToOffset(ScrollOffset(x, y));
+    layer->scrollToOffset(ScrollOffset(x, y), ScrollClamping::Unclamped);
     if (adjustForIOSCaret)
         layer->setAdjustForIOSCaretWhenScrolling(false);
 }
     if (adjustForIOSCaret)
         layer->setAdjustForIOSCaretWhenScrolling(false);
 }