More scrollOffset/scrollPosition disambiguation, in RenderLayer
authorsimon.fraser@apple.com <simon.fraser@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 31 Dec 2015 20:07:15 +0000 (20:07 +0000)
committersimon.fraser@apple.com <simon.fraser@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 31 Dec 2015 20:07:15 +0000 (20:07 +0000)
https://bugs.webkit.org/show_bug.cgi?id=152617

Reviewed by Zalan Bujtas.

Change RenderLayer's m_scrollOffset to be m_scrollPosition, since it stores
scroll positions (negative in RTL overflow). scrollOffset() was accurately
named already, but fix the return type, and remove the unnecessary scrollXOffset()/
scrollYOffset() variants, fixing callers to use .x() and .y().

scrollToOffset() was also accurately named, but fix its argument.

Fix functions related to saving scroll positions on Element to refer to scroll positions.

No behavior change.

* accessibility/AccessibilityRenderObject.cpp:
(WebCore::AccessibilityRenderObject::scrollTo):
* dom/Element.cpp:
(WebCore::Element::removedFrom):
(WebCore::Element::savedLayerScrollPosition):
(WebCore::Element::setSavedLayerScrollPosition):
(WebCore::Element::savedLayerScrollOffset): Deleted.
(WebCore::Element::setSavedLayerScrollOffset): Deleted.
* dom/Element.h:
* dom/ElementRareData.h:
(WebCore::ElementRareData::savedLayerScrollPosition):
(WebCore::ElementRareData::setSavedLayerScrollPosition):
(WebCore::ElementRareData::savedLayerScrollOffset): Deleted.
(WebCore::ElementRareData::setSavedLayerScrollOffset): Deleted.
* html/TextFieldInputType.cpp:
(WebCore::TextFieldInputType::forwardEvent):
* platform/graphics/IntPoint.h:
(WebCore::IntPoint::isZero):
* rendering/RenderBlock.cpp:
(WebCore::RenderBlock::baselinePosition):
* rendering/RenderBox.cpp:
(WebCore::RenderBox::styleDidChange):
(WebCore::RenderBox::scrollLeft):
(WebCore::RenderBox::scrollTop):
(WebCore::RenderBox::scrolledContentOffset):
* rendering/RenderLayer.cpp:
(WebCore::RenderLayer::RenderLayer):
(WebCore::RenderLayer::~RenderLayer):
(WebCore::RenderLayer::scrollByRecursively):
(WebCore::RenderLayer::clampScrollOffset):
(WebCore::RenderLayer::scrollToOffset):
(WebCore::RenderLayer::scrollTo):
(WebCore::RenderLayer::scrollRectToVisible):
(WebCore::RenderLayer::scrollPosition):
(WebCore::RenderLayer::maximumScrollPosition):
(WebCore::RenderLayer::updateScrollInfoAfterLayout):
* rendering/RenderLayer.h:
* rendering/RenderLayerBacking.cpp:
(WebCore::RenderLayerBacking::updateGeometry):
* rendering/RenderMarquee.cpp:
(WebCore::RenderMarquee::start):
(WebCore::RenderMarquee::timerFired):
* rendering/RenderTreeAsText.cpp:
(WebCore::write):

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

16 files changed:
Source/WebCore/ChangeLog
Source/WebCore/accessibility/AccessibilityRenderObject.cpp
Source/WebCore/bindings/objc/DOMHTML.mm
Source/WebCore/dom/Element.cpp
Source/WebCore/dom/Element.h
Source/WebCore/dom/ElementRareData.h
Source/WebCore/html/TextFieldInputType.cpp
Source/WebCore/page/Frame.cpp
Source/WebCore/platform/graphics/IntPoint.h
Source/WebCore/rendering/RenderBlock.cpp
Source/WebCore/rendering/RenderBox.cpp
Source/WebCore/rendering/RenderLayer.cpp
Source/WebCore/rendering/RenderLayer.h
Source/WebCore/rendering/RenderLayerBacking.cpp
Source/WebCore/rendering/RenderMarquee.cpp
Source/WebCore/rendering/RenderTreeAsText.cpp

index 1ea6207..4c77e51 100644 (file)
@@ -1,3 +1,66 @@
+2015-12-31  Simon Fraser  <simon.fraser@apple.com>
+
+        More scrollOffset/scrollPosition disambiguation, in RenderLayer
+        https://bugs.webkit.org/show_bug.cgi?id=152617
+
+        Reviewed by Zalan Bujtas.
+        
+        Change RenderLayer's m_scrollOffset to be m_scrollPosition, since it stores
+        scroll positions (negative in RTL overflow). scrollOffset() was accurately
+        named already, but fix the return type, and remove the unnecessary scrollXOffset()/
+        scrollYOffset() variants, fixing callers to use .x() and .y().
+        
+        scrollToOffset() was also accurately named, but fix its argument.
+        
+        Fix functions related to saving scroll positions on Element to refer to scroll positions.
+
+        No behavior change.
+
+        * accessibility/AccessibilityRenderObject.cpp:
+        (WebCore::AccessibilityRenderObject::scrollTo):
+        * dom/Element.cpp:
+        (WebCore::Element::removedFrom):
+        (WebCore::Element::savedLayerScrollPosition):
+        (WebCore::Element::setSavedLayerScrollPosition):
+        (WebCore::Element::savedLayerScrollOffset): Deleted.
+        (WebCore::Element::setSavedLayerScrollOffset): Deleted.
+        * dom/Element.h:
+        * dom/ElementRareData.h:
+        (WebCore::ElementRareData::savedLayerScrollPosition):
+        (WebCore::ElementRareData::setSavedLayerScrollPosition):
+        (WebCore::ElementRareData::savedLayerScrollOffset): Deleted.
+        (WebCore::ElementRareData::setSavedLayerScrollOffset): Deleted.
+        * html/TextFieldInputType.cpp:
+        (WebCore::TextFieldInputType::forwardEvent):
+        * platform/graphics/IntPoint.h:
+        (WebCore::IntPoint::isZero):
+        * rendering/RenderBlock.cpp:
+        (WebCore::RenderBlock::baselinePosition):
+        * rendering/RenderBox.cpp:
+        (WebCore::RenderBox::styleDidChange):
+        (WebCore::RenderBox::scrollLeft):
+        (WebCore::RenderBox::scrollTop):
+        (WebCore::RenderBox::scrolledContentOffset):
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::RenderLayer):
+        (WebCore::RenderLayer::~RenderLayer):
+        (WebCore::RenderLayer::scrollByRecursively):
+        (WebCore::RenderLayer::clampScrollOffset):
+        (WebCore::RenderLayer::scrollToOffset):
+        (WebCore::RenderLayer::scrollTo):
+        (WebCore::RenderLayer::scrollRectToVisible):
+        (WebCore::RenderLayer::scrollPosition):
+        (WebCore::RenderLayer::maximumScrollPosition):
+        (WebCore::RenderLayer::updateScrollInfoAfterLayout):
+        * rendering/RenderLayer.h:
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::updateGeometry):
+        * rendering/RenderMarquee.cpp:
+        (WebCore::RenderMarquee::start):
+        (WebCore::RenderMarquee::timerFired):
+        * rendering/RenderTreeAsText.cpp:
+        (WebCore::write):
+
 2015-12-31  Zalan Bujtas  <zalan@apple.com>
 
         text-decoration: line-through is mispositioned when text has overline/underline too.
index b844c25..a20e9c2 100644 (file)
@@ -3577,7 +3577,8 @@ void AccessibilityRenderObject::scrollTo(const IntPoint& point) const
     if (!box.canBeScrolledAndHasScrollableArea())
         return;
 
-    box.layer()->scrollToOffset(toIntSize(point), RenderLayer::ScrollOffsetClamped);
+    // FIXME: is point a ScrollOffset or ScrollPosition? Test in RTL overflow.
+    box.layer()->scrollToOffset(point, RenderLayer::ScrollOffsetClamped);
 }
 
 #if ENABLE(MATHML)
index 027595e..0c03f96 100644 (file)
@@ -77,7 +77,7 @@ using namespace WebCore;
     if (!is<RenderBox>(*renderer) || !renderer->hasOverflowClip())
         return 0;
 
-    return downcast<RenderBox>(*renderer).layer()->scrollXOffset();
+    return downcast<RenderBox>(*renderer).layer()->scrollOffset().x();
 }
 
 - (int)scrollYOffset
@@ -91,7 +91,7 @@ using namespace WebCore;
     if (!is<RenderBox>(*renderer) || !renderer->hasOverflowClip())
         return 0;
 
-    return downcast<RenderBox>(*renderer).layer()->scrollYOffset();
+    return downcast<RenderBox>(*renderer).layer()->scrollOffset().y();
 }
 
 - (void)setScrollXOffset:(int)x scrollYOffset:(int)y
@@ -113,12 +113,13 @@ using namespace WebCore;
     RenderLayer* layer = downcast<RenderBox>(*renderer).layer();
     if (adjustForIOSCaret)
         layer->setAdjustForIOSCaretWhenScrolling(true);
-    layer->scrollToOffset(IntSize(x, y));
+    layer->scrollToOffset(ScrollOffset(x, y));
     if (adjustForIOSCaret)
         layer->setAdjustForIOSCaretWhenScrolling(false);
 }
 
-- (void)absolutePosition:(int *)x :(int *)y :(int *)w :(int *)h {
+- (void)absolutePosition:(int *)x :(int *)y :(int *)w :(int *)h
+{
     RenderBox *renderer = core(self)->renderBox();
     if (renderer) {
         if (w)
index a771f4d..6b38a3e 100644 (file)
@@ -1575,7 +1575,7 @@ void Element::removedFrom(ContainerNode& insertionPoint)
         document().page()->pointerLockController().elementRemoved(this);
 #endif
 
-    setSavedLayerScrollOffset(IntSize());
+    setSavedLayerScrollPosition(ScrollPosition());
 
     if (insertionPoint.isInTreeScope()) {
         TreeScope* oldScope = &insertionPoint.treeScope();
@@ -3152,16 +3152,16 @@ void Element::didRemoveAttribute(const QualifiedName& name, const AtomicString&
     dispatchSubtreeModifiedEvent();
 }
 
-IntSize Element::savedLayerScrollOffset() const
+IntPoint Element::savedLayerScrollPosition() const
 {
-    return hasRareData() ? elementRareData()->savedLayerScrollOffset() : IntSize();
+    return hasRareData() ? elementRareData()->savedLayerScrollPosition() : IntPoint();
 }
 
-void Element::setSavedLayerScrollOffset(const IntSize& size)
+void Element::setSavedLayerScrollPosition(const IntPoint& position)
 {
-    if (size.isZero() && !hasRareData())
+    if (position.isZero() && !hasRareData())
         return;
-    ensureElementRareData().setSavedLayerScrollOffset(size);
+    ensureElementRareData().setSavedLayerScrollPosition(position);
 }
 
 RefPtr<Attr> Element::attrIfExists(const AtomicString& localName, bool shouldIgnoreAttributeCase)
index 1f14861..0942a42 100644 (file)
@@ -452,8 +452,8 @@ public:
     bool hasName() const;
     const SpaceSplitString& classNames() const;
 
-    IntSize savedLayerScrollOffset() const;
-    void setSavedLayerScrollOffset(const IntSize&);
+    IntPoint savedLayerScrollPosition() const;
+    void setSavedLayerScrollPosition(const IntPoint&);
 
     bool dispatchMouseEvent(const PlatformMouseEvent&, const AtomicString& eventType, int clickCount = 0, Element* relatedTarget = nullptr);
     bool dispatchWheelEvent(const PlatformWheelEvent&);
index 5981cf4..bae75d6 100644 (file)
@@ -101,8 +101,8 @@ public:
     LayoutSize minimumSizeForResizing() const { return m_minimumSizeForResizing; }
     void setMinimumSizeForResizing(LayoutSize size) { m_minimumSizeForResizing = size; }
 
-    IntSize savedLayerScrollOffset() const { return m_savedLayerScrollOffset; }
-    void setSavedLayerScrollOffset(IntSize size) { m_savedLayerScrollOffset = size; }
+    IntPoint savedLayerScrollPosition() const { return m_savedLayerScrollPosition; }
+    void setSavedLayerScrollPosition(IntPoint position) { m_savedLayerScrollPosition = position; }
 
     bool hasPendingResources() const { return m_hasPendingResources; }
     void setHasPendingResources(bool has) { m_hasPendingResources = has; }
@@ -130,7 +130,7 @@ private:
     RegionOversetState m_regionOversetState;
 
     LayoutSize m_minimumSizeForResizing;
-    IntSize m_savedLayerScrollOffset;
+    IntPoint m_savedLayerScrollPosition;
     RefPtr<RenderStyle> m_computedStyle;
 
     std::unique_ptr<DatasetDOMStringMap> m_dataset;
index 7a08dd7..45e0ece 100644 (file)
@@ -197,7 +197,7 @@ void TextFieldInputType::forwardEvent(Event* event)
             if (event->type() == eventNames().blurEvent) {
                 if (RenderTextControlInnerBlock* innerTextRenderer = innerTextElement()->renderer()) {
                     if (RenderLayer* innerLayer = innerTextRenderer->layer()) {
-                        IntSize scrollOffset(!renderTextControl.style().isLeftToRightDirection() ? innerLayer->scrollWidth() : 0, 0);
+                        ScrollOffset scrollOffset(!renderTextControl.style().isLeftToRightDirection() ? innerLayer->scrollWidth() : 0, 0);
                         innerLayer->scrollToOffset(scrollOffset, RenderLayer::ScrollOffsetClamped);
                     }
                 }
index c4c8673..a394eda 100644 (file)
@@ -490,25 +490,25 @@ void Frame::scrollOverflowLayer(RenderLayer* layer, const IntRect& visibleRect,
     if (visibleRect.intersects(exposeRect))
         return;
 
-    int x = layer->scrollXOffset();
+    // FIXME: Why isn't this just calling RenderLayer::scrollRectToVisible()?
+    ScrollOffset scrollOffset = layer->scrollOffset();
     int exposeLeft = exposeRect.x();
     int exposeRight = exposeLeft + exposeRect.width();
     int clientWidth = roundToInt(box->clientWidth());
     if (exposeLeft <= 0)
-        x = std::max(0, x + exposeLeft - clientWidth / 2);
+        scrollOffset.setX(std::max(0, scrollOffset.x() + exposeLeft - clientWidth / 2));
     else if (exposeRight >= clientWidth)
-        x = std::min(box->scrollWidth() - clientWidth, x + clientWidth / 2);
+        scrollOffset.setX(std::min(box->scrollWidth() - clientWidth, scrollOffset.x() + clientWidth / 2));
 
-    int y = layer->scrollYOffset();
     int exposeTop = exposeRect.y();
     int exposeBottom = exposeTop + exposeRect.height();
     int clientHeight = roundToInt(box->clientHeight());
     if (exposeTop <= 0)
-        y = std::max(0, y + exposeTop - clientHeight / 2);
+        scrollOffset.setY(std::max(0, scrollOffset.y() + exposeTop - clientHeight / 2));
     else if (exposeBottom >= clientHeight)
-        y = std::min(box->scrollHeight() - clientHeight, y + clientHeight / 2);
+        scrollOffset.setY(std::min(box->scrollHeight() - clientHeight, scrollOffset.y() + clientHeight / 2));
 
-    layer->scrollToOffset(IntSize(x, y));
+    layer->scrollToOffset(scrollOffset);
     selection().setCaretRectNeedsUpdate();
     selection().updateAppearance();
 }
@@ -602,7 +602,7 @@ int Frame::checkOverflowScroll(OverflowScrollAction action)
     }
 
     if (action == PerformOverflowScroll && (deltaX || deltaY)) {
-        layer->scrollToOffset(IntSize(layer->scrollXOffset() + deltaX, layer->scrollYOffset() + deltaY));
+        layer->scrollToOffset(layer->scrollOffset() + IntSize(deltaX, deltaY));
 
         // Handle making selection.
         VisiblePosition visiblePosition(renderer->positionForPoint(selectionPosition, nullptr));
index 0b5d43a..3390f44 100644 (file)
@@ -66,6 +66,7 @@ public:
     explicit IntPoint(const FloatPoint&); // don't do this implicitly since it's lossy
 
     static IntPoint zero() { return IntPoint(); }
+    bool isZero() const { return !m_x && !m_y; }
 
     int x() const { return m_x; }
     int y() const { return m_y; }
index f79518b..3fc3d22 100644 (file)
@@ -2874,8 +2874,8 @@ int RenderBlock::baselinePosition(FontBaseline baselineType, bool firstLine, Lin
         // (the content inside them moves).  This matches WinIE as well, which just bottom-aligns them.
         // We also give up on finding a baseline if we have a vertical scrollbar, or if we are scrolled
         // vertically (e.g., an overflow:hidden block that has had scrollTop moved).
-        bool ignoreBaseline = (layer() && (layer()->marquee() || (direction == HorizontalLine ? (layer()->verticalScrollbar() || layer()->scrollYOffset() != 0)
-            : (layer()->horizontalScrollbar() || layer()->scrollXOffset() != 0)))) || (isWritingModeRoot() && !isRubyRun());
+        bool ignoreBaseline = (layer() && (layer()->marquee() || (direction == HorizontalLine ? (layer()->verticalScrollbar() || layer()->scrollOffset().y() != 0)
+            : (layer()->horizontalScrollbar() || layer()->scrollOffset().x() != 0)))) || (isWritingModeRoot() && !isRubyRun());
         
         Optional<int> baselinePos = ignoreBaseline ? Optional<int>() : inlineBlockBaseline(direction);
         
index 0673519..6872ce0 100644 (file)
@@ -356,11 +356,11 @@ void RenderBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle
     // If our zoom factor changes and we have a defined scrollLeft/Top, we need to adjust that value into the
     // new zoomed coordinate space.
     if (hasOverflowClip() && layer() && oldStyle && oldStyle->effectiveZoom() != newStyle.effectiveZoom()) {
-        if (int left = layer()->scrollXOffset()) {
+        if (int left = layer()->scrollOffset().x()) {
             left = (left / oldStyle->effectiveZoom()) * newStyle.effectiveZoom();
             layer()->scrollToXOffset(left);
         }
-        if (int top = layer()->scrollYOffset()) {
+        if (int top = layer()->scrollOffset().y()) {
             top = (top / oldStyle->effectiveZoom()) * newStyle.effectiveZoom();
             layer()->scrollToYOffset(top);
         }
@@ -578,12 +578,12 @@ int RenderBox::scrollHeight() const
 
 int RenderBox::scrollLeft() const
 {
-    return hasOverflowClip() && layer() ? layer()->scrollXOffset() : 0;
+    return hasOverflowClip() && layer() ? layer()->scrollOffset().x() : 0;
 }
 
 int RenderBox::scrollTop() const
 {
-    return hasOverflowClip() && layer() ? layer()->scrollYOffset() : 0;
+    return hasOverflowClip() && layer() ? layer()->scrollOffset().y() : 0;
 }
 
 static void setupWheelEventTestTrigger(RenderLayer& layer, Frame* frame)
@@ -978,6 +978,7 @@ IntSize RenderBox::scrolledContentOffset() const
         return IntSize();
 
     ASSERT(hasLayer());
+    // FIXME: Renderer code needs scrollOffset/scrollPosition disambiguation.
     return layer()->scrolledContentOffset();
 }
 
index 97bc192..228abd1 100644 (file)
@@ -333,10 +333,10 @@ RenderLayer::RenderLayer(RenderLayerModelObject& rendererLayerModelObject)
 
     if (Element* element = renderer().element()) {
         // We save and restore only the scrollOffset as the other scroll values are recalculated.
-        m_scrollOffset = element->savedLayerScrollOffset();
-        if (!m_scrollOffset.isZero())
-            scrollAnimator().setCurrentPosition(FloatPoint(m_scrollOffset.width(), m_scrollOffset.height()));
-        element->setSavedLayerScrollOffset(IntSize());
+        m_scrollPosition = element->savedLayerScrollPosition();
+        if (!m_scrollPosition.isZero())
+            scrollAnimator().setCurrentPosition(m_scrollPosition);
+        element->setSavedLayerScrollPosition(IntPoint());
     }
 }
 
@@ -352,7 +352,7 @@ RenderLayer::~RenderLayer()
         unregisterAsTouchEventListenerForScrolling();
 #endif
         if (Element* element = renderer().element())
-            element->setSavedLayerScrollOffset(m_scrollOffset);
+            element->setSavedLayerScrollPosition(m_scrollPosition);
     }
 
     destroyScrollbar(HorizontalScrollbar);
@@ -2289,7 +2289,7 @@ void RenderLayer::scrollByRecursively(const IntSize& delta, ScrollOffsetClamping
         restrictedByLineClamp = !renderer().parent()->style().lineClamp().isNone();
 
     if (renderer().hasOverflowClip() && !restrictedByLineClamp) {
-        IntSize newScrollOffset = scrollOffset() + delta;
+        ScrollOffset newScrollOffset = scrollOffset() + delta;
         scrollToOffset(newScrollOffset, clamp);
         if (scrolledArea)
             *scrolledArea = this;
@@ -2314,26 +2314,20 @@ void RenderLayer::scrollByRecursively(const IntSize& delta, ScrollOffsetClamping
     }
 }
 
-IntSize RenderLayer::clampScrollOffset(const IntSize& scrollOffset) const
+ScrollOffset RenderLayer::clampScrollOffset(const ScrollOffset& scrollOffset) const
 {
-    RenderBox* box = renderBox();
-    ASSERT(box);
-
-    int maxX = scrollWidth() - roundToInt(box->clientWidth());
-    int maxY = scrollHeight() - roundToInt(box->clientHeight());
-
-    int x = std::max(std::min(scrollOffset.width(), maxX), 0);
-    int y = std::max(std::min(scrollOffset.height(), maxY), 0);
-    return IntSize(x, y);
+    return scrollOffset.constrainedBetween(IntPoint(), maximumScrollOffset());
 }
 
-void RenderLayer::scrollToOffset(const IntSize& scrollOffset, ScrollOffsetClamping clamp)
+void RenderLayer::scrollToOffset(const ScrollOffset& scrollOffset, ScrollOffsetClamping clamp)
 {
-    IntSize newScrollOffset = clamp == ScrollOffsetClamped ? clampScrollOffset(scrollOffset) : scrollOffset;
+    ScrollOffset newScrollOffset = clamp == ScrollOffsetClamped ? clampScrollOffset(scrollOffset) : scrollOffset;
     if (newScrollOffset != this->scrollOffset())
-        scrollToOffsetWithoutAnimation(IntPoint(newScrollOffset));
+        scrollToOffsetWithoutAnimation(newScrollOffset);
 }
 
+// x and y are scroll offset values
+// FIXME: use a ScrollOffset, or change this to take a ScrollPosition.
 void RenderLayer::scrollTo(int x, int y)
 {
     RenderBox* box = renderBox();
@@ -2351,7 +2345,7 @@ void RenderLayer::scrollTo(int x, int y)
                 x += caretWidth;
                 if (x <= caretWidth)
                     x = 0;
-            } else if (x < m_scrollOffset.width() - caretWidth)
+            } else if (x < m_scrollPosition.x() - caretWidth)
                 x -= caretWidth;
         }
 #endif
@@ -2362,8 +2356,8 @@ void RenderLayer::scrollTo(int x, int y)
     // complicated (since it will involve testing whether our layer
     // is either occluded by another layer or clipped by an enclosing
     // layer or contains fixed backgrounds, etc.).
-    IntSize newScrollOffset = IntSize(x - scrollOrigin().x(), y - scrollOrigin().y());
-    if (m_scrollOffset == newScrollOffset) {
+    ScrollPosition newScrollPosition = scrollPositionFromOffset(ScrollOffset(x, y));
+    if (m_scrollPosition == newScrollPosition) {
 #if PLATFORM(IOS)
         if (m_requiresScrollBoundsOriginUpdate)
             updateCompositingLayersAfterScroll();
@@ -2371,8 +2365,8 @@ void RenderLayer::scrollTo(int x, int y)
         return;
     }
     
-    IntPoint oldPosition = IntPoint(m_scrollOffset);
-    m_scrollOffset = newScrollOffset;
+    ScrollPosition oldPosition = IntPoint(m_scrollPosition);
+    m_scrollPosition = newScrollPosition;
 
     RenderView& view = renderer().view();
 
@@ -2423,7 +2417,7 @@ void RenderLayer::scrollTo(int x, int y)
     // Schedule the scroll and scroll-related DOM events.
     if (Element* element = renderer().element()) {
         element->document().eventQueue().enqueueOrDispatchScrollEvent(*element);
-        element->document().sendWillRevealEdgeEventsIfNeeded(oldPosition, IntPoint(newScrollOffset), visibleContentRect(), contentsSize(), element);
+        element->document().sendWillRevealEdgeEventsIfNeeded(oldPosition, newScrollPosition, visibleContentRect(), contentsSize(), element);
     }
 
     if (scrollsOverflow())
@@ -2493,9 +2487,9 @@ void RenderLayer::scrollRectToVisible(const LayoutRect& rect, const ScrollAlignm
         LayoutRect layerBounds(0, 0, box->clientWidth(), box->clientHeight());
         LayoutRect r = getRectToExpose(layerBounds, layerBounds, localExposeRect, alignX, alignY);
 
-        IntSize clampedScrollOffset = clampScrollOffset(scrollOffset() + toIntSize(roundedIntRect(r).location()));
+        ScrollOffset clampedScrollOffset = clampScrollOffset(scrollOffset() + toIntSize(roundedIntRect(r).location()));
         if (clampedScrollOffset != scrollOffset()) {
-            IntSize oldScrollOffset = scrollOffset();
+            ScrollOffset oldScrollOffset = scrollOffset();
             scrollToOffset(clampedScrollOffset);
             IntSize scrollOffsetDifference = scrollOffset() - oldScrollOffset;
             localExposeRect.move(-scrollOffsetDifference);
@@ -2734,21 +2728,16 @@ void RenderLayer::setScrollOffset(const IntPoint& offset)
 int RenderLayer::scrollPosition(Scrollbar* scrollbar) const
 {
     if (scrollbar->orientation() == HorizontalScrollbar)
-        return scrollXOffset();
+        return scrollOffset().x();
     if (scrollbar->orientation() == VerticalScrollbar)
-        return scrollYOffset();
+        return scrollOffset().y();
     return 0;
 }
 
-ScrollPosition RenderLayer::scrollPosition() const
-{
-    // FIXME: This needs scrollOffset/scrollPosition disambiguation.
-    return ScrollPosition(m_scrollOffset);
-}
-
 ScrollPosition RenderLayer::maximumScrollPosition() const
 {
     // FIXME: m_scrollSize may not be up-to-date if m_scrollDimensionsDirty is true.
+    // FIXME: should be able to use the ScrollableArea implementation.
     return scrollPositionFromOffset(roundedIntPoint(m_scrollSize) - visibleContentRectIncludingScrollbars(ContentsVisibleRect).size());
 }
 
@@ -3476,7 +3465,7 @@ void RenderLayer::updateScrollInfoAfterLayout()
         return;
 
     m_scrollDimensionsDirty = true;
-    IntSize originalScrollOffset = scrollOffset();
+    ScrollOffset originalScrollOffset = scrollOffset();
 
     computeScrollDimensions();
 
@@ -3489,7 +3478,7 @@ void RenderLayer::updateScrollInfoAfterLayout()
     if (box->style().overflowX() != OMARQUEE && !isRubberBandInProgress()) {
         // 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).
-        IntSize clampedScrollOffset = clampScrollOffset(scrollOffset());
+        ScrollOffset clampedScrollOffset = clampScrollOffset(scrollOffset());
 #if PLATFORM(IOS)
         // FIXME: This looks wrong. The caret adjust mode should only be enabled on editing related entry points.
         // This code was added to fix an issue where the text insertion point would always be drawn on the right edge
index cb15914..dd6d899 100644 (file)
@@ -191,14 +191,13 @@ public:
     };
 
     // Scrolling methods for layers that can scroll their overflow.
-    void scrollByRecursively(const IntSize&, ScrollOffsetClamping = ScrollOffsetUnclamped, ScrollableArea** scrolledArea = nullptr);
-    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 scrollByRecursively(const IntSize& delta, ScrollOffsetClamping = ScrollOffsetUnclamped, ScrollableArea** scrolledArea = nullptr);
+
+    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); }
+
+    ScrollOffset scrollOffset() const { return scrollOffsetFromPosition(m_scrollPosition); }
     IntSize scrollableContentsSize() const;
 
     void scrollRectToVisible(const LayoutRect&, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
@@ -751,9 +750,10 @@ private:
     void updateLayerPositionsAfterScroll(RenderGeometryMap*, UpdateLayerPositionsAfterScrollFlags = NoFlag);
 
     friend IntSize RenderBox::scrolledContentOffset() const;
-    IntSize scrolledContentOffset() const { return m_scrollOffset; }
+    // FIXME: rename this toscrolledContentPosition(), or remove it.
+    IntSize scrolledContentOffset() const { return toIntSize(m_scrollPosition); }
 
-    IntSize clampScrollOffset(const IntSize&) const;
+    ScrollOffset clampScrollOffset(const ScrollOffset&) const;
 
     RenderLayer* enclosingPaginationLayerInSubtree(const RenderLayer* rootLayer, PaginationInclusionMode) const;
 
@@ -865,7 +865,7 @@ private:
     virtual int scrollSize(ScrollbarOrientation) const override;
     virtual void setScrollOffset(const IntPoint&) override;
 
-    virtual ScrollPosition scrollPosition() const override;
+    virtual ScrollPosition scrollPosition() const override { return m_scrollPosition; }
     virtual ScrollPosition maximumScrollPosition() const override;
 
     virtual IntRect visibleContentRectInternal(VisibleContentRectIncludesScrollbars, VisibleContentRectBehavior) const override;
@@ -1093,8 +1093,7 @@ private:
     // The layer's width/height
     IntSize m_layerSize;
 
-    // This is the (scroll) offset from scrollOrigin().
-    IntSize m_scrollOffset;
+    ScrollPosition m_scrollPosition;
 
     // The width/height of our scrolled area.
     LayoutSize m_scrollSize;
index 61f2203..1449c4f 100644 (file)
@@ -947,7 +947,7 @@ void RenderLayerBacking::updateGeometry()
         ASSERT(m_scrollingContentsLayer);
         auto& renderBox = downcast<RenderBox>(renderer());
         LayoutRect paddingBox(renderBox.borderLeft(), renderBox.borderTop(), renderBox.width() - renderBox.borderLeft() - renderBox.borderRight(), renderBox.height() - renderBox.borderTop() - renderBox.borderBottom());
-        LayoutSize scrollOffset = m_owningLayer.scrollOffset();
+        ScrollOffset scrollOffset = m_owningLayer.scrollOffset();
 
         // FIXME: need to do some pixel snapping here.
         m_scrollingLayer->setPosition(FloatPoint(paddingBox.location() - localCompositingBounds.location()));
@@ -960,11 +960,11 @@ void RenderLayerBacking::updateGeometry()
 
         if (m_owningLayer.isInUserScroll()) {
             // If scrolling is happening externally, we don't want to touch the layer bounds origin here because that will cause jitter.
-            m_scrollingLayer->syncBoundsOrigin(FloatPoint(scrollOffset.width(), scrollOffset.height()));
+            m_scrollingLayer->syncBoundsOrigin(scrollOffset);
             m_owningLayer.setRequiresScrollBoundsOriginUpdate(true);
         } else {
             // Note that we implement the contents offset via the bounds origin on this layer, rather than a position on the sublayer.
-            m_scrollingLayer->setBoundsOrigin(FloatPoint(scrollOffset.width(), scrollOffset.height()));
+            m_scrollingLayer->setBoundsOrigin(scrollOffset);
             m_owningLayer.setRequiresScrollBoundsOriginUpdate(false);
         }
         
@@ -978,9 +978,10 @@ void RenderLayerBacking::updateGeometry()
         m_scrollingContentsLayer->setSize(scrollSize);
         // Scrolling the content layer does not need to trigger a repaint. The offset will be compensated away during painting.
         // FIXME: The paint offset and the scroll offset should really be separate concepts.
-        m_scrollingContentsLayer->setOffsetFromRenderer(paddingBox.location() - IntPoint() - scrollOffset, GraphicsLayer::DontSetNeedsDisplay);
+        LayoutSize scrollingContentsOffset = toLayoutSize(paddingBox.location() - toLayoutSize(scrollOffset));
+        m_scrollingContentsLayer->setOffsetFromRenderer(scrollingContentsOffset, GraphicsLayer::DontSetNeedsDisplay);
 #else
-        m_scrollingContentsLayer->setPosition(FloatPoint(-scrollOffset.width(), -scrollOffset.height()));
+        m_scrollingContentsLayer->setPosition(-scrollOffset);
 
         FloatSize oldScrollingLayerOffset = m_scrollingLayer->offsetFromRenderer();
         m_scrollingLayer->setOffsetFromRenderer(-toFloatSize(paddingBox.location()));
@@ -997,7 +998,7 @@ void RenderLayerBacking::updateGeometry()
         if (scrollSize != m_scrollingContentsLayer->size() || paddingBoxOffsetChanged)
             m_scrollingContentsLayer->setNeedsDisplay();
 
-        LayoutSize scrollingContentsOffset = toLayoutSize(paddingBox.location() - scrollOffset);
+        LayoutSize scrollingContentsOffset = toLayoutSize(paddingBox.location() - toLayoutSize(scrollOffset));
         if (scrollingContentsOffset != m_scrollingContentsLayer->offsetFromRenderer() || scrollSize != m_scrollingContentsLayer->size())
             compositor().scrollingLayerDidChange(m_owningLayer);
 
@@ -2249,7 +2250,7 @@ void RenderLayerBacking::setContentsNeedDisplayInRect(const LayoutRect& r, Graph
         layerDirtyRect.move(-m_scrollingContentsLayer->offsetFromRenderer() + m_devicePixelFractionFromRenderer);
 #if PLATFORM(IOS)
         // Account for the fact that RenderLayerBacking::updateGeometry() bakes scrollOffset into offsetFromRenderer on iOS.
-        layerDirtyRect.move(-m_owningLayer.scrollOffset() + m_devicePixelFractionFromRenderer);
+        layerDirtyRect.moveBy(-m_owningLayer.scrollOffset() + m_devicePixelFractionFromRenderer);
 #endif
         m_scrollingContentsLayer->setNeedsDisplayInRect(layerDirtyRect, shouldClip);
     }
index 585d3f8..113c680 100644 (file)
@@ -159,9 +159,9 @@ void RenderMarquee::start()
 
     if (!m_suspended && !m_stopped) {
         if (isHorizontal())
-            m_layer->scrollToOffset(IntSize(m_start, 0));
+            m_layer->scrollToOffset(ScrollOffset(m_start, 0));
         else
-            m_layer->scrollToOffset(IntSize(0, m_start));
+            m_layer->scrollToOffset(ScrollOffset(0, m_start));
     }
     else {
         m_suspended = false;
@@ -274,7 +274,7 @@ void RenderMarquee::timerFired()
         bool positive = range > 0;
         int clientSize = (isHorizontal() ? roundToInt(m_layer->renderBox()->clientWidth()) : roundToInt(m_layer->renderBox()->clientHeight()));
         int increment = abs(intValueForLength(m_layer->renderer().style().marqueeIncrement(), clientSize));
-        int currentPos = (isHorizontal() ? m_layer->scrollXOffset() : m_layer->scrollYOffset());
+        int currentPos = (isHorizontal() ? m_layer->scrollOffset().x() : m_layer->scrollOffset().y());
         newPos =  currentPos + (addIncrement ? increment : -increment);
         if (positive)
             newPos = std::min(newPos, endPoint);
index c988ce6..00f245e 100644 (file)
@@ -617,10 +617,10 @@ static void write(TextStream& ts, RenderLayer& l,
     }
 
     if (l.renderer().hasOverflowClip()) {
-        if (l.scrollXOffset())
-            ts << " scrollX " << l.scrollXOffset();
-        if (l.scrollYOffset())
-            ts << " scrollY " << l.scrollYOffset();
+        if (l.scrollOffset().x())
+            ts << " scrollX " << l.scrollOffset().x();
+        if (l.scrollOffset().y())
+            ts << " scrollY " << l.scrollOffset().y();
         if (l.renderBox() && roundToInt(l.renderBox()->clientWidth()) != l.scrollWidth())
             ts << " scrollWidth " << l.scrollWidth();
         if (l.renderBox() && roundToInt(l.renderBox()->clientHeight()) != l.scrollHeight())