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