Diff
Modified: trunk/Source/WebCore/ChangeLog (194465 => 194466)
--- trunk/Source/WebCore/ChangeLog 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/ChangeLog 2015-12-31 20:07:15 UTC (rev 194466)
@@ -1,3 +1,66 @@
+2015-12-31 Simon Fraser <simon.fra...@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 <za...@apple.com>
text-decoration: line-through is mispositioned when text has overline/underline too.
Modified: trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp (194465 => 194466)
--- trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp 2015-12-31 20:07:15 UTC (rev 194466)
@@ -3577,7 +3577,8 @@
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)
Modified: trunk/Source/WebCore/bindings/objc/DOMHTML.mm (194465 => 194466)
--- trunk/Source/WebCore/bindings/objc/DOMHTML.mm 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/bindings/objc/DOMHTML.mm 2015-12-31 20:07:15 UTC (rev 194466)
@@ -77,7 +77,7 @@
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 @@
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 @@
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)
Modified: trunk/Source/WebCore/dom/Element.cpp (194465 => 194466)
--- trunk/Source/WebCore/dom/Element.cpp 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/dom/Element.cpp 2015-12-31 20:07:15 UTC (rev 194466)
@@ -1575,7 +1575,7 @@
document().page()->pointerLockController().elementRemoved(this);
#endif
- setSavedLayerScrollOffset(IntSize());
+ setSavedLayerScrollPosition(ScrollPosition());
if (insertionPoint.isInTreeScope()) {
TreeScope* oldScope = &insertionPoint.treeScope();
@@ -3152,16 +3152,16 @@
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)
Modified: trunk/Source/WebCore/dom/Element.h (194465 => 194466)
--- trunk/Source/WebCore/dom/Element.h 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/dom/Element.h 2015-12-31 20:07:15 UTC (rev 194466)
@@ -452,8 +452,8 @@
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&);
Modified: trunk/Source/WebCore/dom/ElementRareData.h (194465 => 194466)
--- trunk/Source/WebCore/dom/ElementRareData.h 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/dom/ElementRareData.h 2015-12-31 20:07:15 UTC (rev 194466)
@@ -101,8 +101,8 @@
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 @@
RegionOversetState m_regionOversetState;
LayoutSize m_minimumSizeForResizing;
- IntSize m_savedLayerScrollOffset;
+ IntPoint m_savedLayerScrollPosition;
RefPtr<RenderStyle> m_computedStyle;
std::unique_ptr<DatasetDOMStringMap> m_dataset;
Modified: trunk/Source/WebCore/html/TextFieldInputType.cpp (194465 => 194466)
--- trunk/Source/WebCore/html/TextFieldInputType.cpp 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/html/TextFieldInputType.cpp 2015-12-31 20:07:15 UTC (rev 194466)
@@ -197,7 +197,7 @@
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);
}
}
Modified: trunk/Source/WebCore/page/Frame.cpp (194465 => 194466)
--- trunk/Source/WebCore/page/Frame.cpp 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/page/Frame.cpp 2015-12-31 20:07:15 UTC (rev 194466)
@@ -490,25 +490,25 @@
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 @@
}
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));
Modified: trunk/Source/WebCore/platform/graphics/IntPoint.h (194465 => 194466)
--- trunk/Source/WebCore/platform/graphics/IntPoint.h 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/platform/graphics/IntPoint.h 2015-12-31 20:07:15 UTC (rev 194466)
@@ -66,6 +66,7 @@
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; }
Modified: trunk/Source/WebCore/rendering/RenderBlock.cpp (194465 => 194466)
--- trunk/Source/WebCore/rendering/RenderBlock.cpp 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/rendering/RenderBlock.cpp 2015-12-31 20:07:15 UTC (rev 194466)
@@ -2874,8 +2874,8 @@
// (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);
Modified: trunk/Source/WebCore/rendering/RenderBox.cpp (194465 => 194466)
--- trunk/Source/WebCore/rendering/RenderBox.cpp 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/rendering/RenderBox.cpp 2015-12-31 20:07:15 UTC (rev 194466)
@@ -356,11 +356,11 @@
// 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::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 @@
return IntSize();
ASSERT(hasLayer());
+ // FIXME: Renderer code needs scrollOffset/scrollPosition disambiguation.
return layer()->scrolledContentOffset();
}
Modified: trunk/Source/WebCore/rendering/RenderLayer.cpp (194465 => 194466)
--- trunk/Source/WebCore/rendering/RenderLayer.cpp 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/rendering/RenderLayer.cpp 2015-12-31 20:07:15 UTC (rev 194466)
@@ -333,10 +333,10 @@
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 @@
unregisterAsTouchEventListenerForScrolling();
#endif
if (Element* element = renderer().element())
- element->setSavedLayerScrollOffset(m_scrollOffset);
+ element->setSavedLayerScrollPosition(m_scrollPosition);
}
destroyScrollbar(HorizontalScrollbar);
@@ -2289,7 +2289,7 @@
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 @@
}
}
-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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
return;
m_scrollDimensionsDirty = true;
- IntSize originalScrollOffset = scrollOffset();
+ ScrollOffset originalScrollOffset = scrollOffset();
computeScrollDimensions();
@@ -3489,7 +3478,7 @@
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
Modified: trunk/Source/WebCore/rendering/RenderLayer.h (194465 => 194466)
--- trunk/Source/WebCore/rendering/RenderLayer.h 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/rendering/RenderLayer.h 2015-12-31 20:07:15 UTC (rev 194466)
@@ -191,14 +191,13 @@
};
// 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); }
+ void scrollByRecursively(const IntSize& delta, ScrollOffsetClamping = ScrollOffsetUnclamped, ScrollableArea** scrolledArea = nullptr);
- 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(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 @@
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 @@
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 @@
// 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;
Modified: trunk/Source/WebCore/rendering/RenderLayerBacking.cpp (194465 => 194466)
--- trunk/Source/WebCore/rendering/RenderLayerBacking.cpp 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/rendering/RenderLayerBacking.cpp 2015-12-31 20:07:15 UTC (rev 194466)
@@ -947,7 +947,7 @@
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 @@
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 @@
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 @@
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 @@
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);
}
Modified: trunk/Source/WebCore/rendering/RenderMarquee.cpp (194465 => 194466)
--- trunk/Source/WebCore/rendering/RenderMarquee.cpp 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/rendering/RenderMarquee.cpp 2015-12-31 20:07:15 UTC (rev 194466)
@@ -159,9 +159,9 @@
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 @@
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);
Modified: trunk/Source/WebCore/rendering/RenderTreeAsText.cpp (194465 => 194466)
--- trunk/Source/WebCore/rendering/RenderTreeAsText.cpp 2015-12-31 19:57:25 UTC (rev 194465)
+++ trunk/Source/WebCore/rendering/RenderTreeAsText.cpp 2015-12-31 20:07:15 UTC (rev 194466)
@@ -617,10 +617,10 @@
}
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())
