Changeset 120832 in webkit


Ignore:
Timestamp:
Jun 20, 2012 10:24:24 AM (12 years ago)
Author:
jchaffraix@webkit.org
Message:

Use IntSize in RenderLayer to represent scroll offsets
​https://bugs.webkit.org/show_bug.cgi?id=89154

Reviewed by Eric Seidel.

Source/WebCore:

Refactoring, covered by existing tests.

  • accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::scrollTo):

  • html/TextFieldInputType.cpp:

(WebCore::TextFieldInputType::forwardEvent):

  • page/SpatialNavigation.cpp:

(WebCore::scrollInDirection):

  • rendering/RenderMarquee.cpp:

(WebCore::RenderMarquee::start):
Updated those call-sites to use the IntSize variant of the scrolling function.

  • rendering/RenderLayer.cpp:

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

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

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

  • rendering/RenderLayer.h:

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

Source/WebKit/blackberry:

  • Api/WebPage.cpp:

(BlackBerry::WebKit::WebPagePrivate::scrollRenderer):
Updated to pass an IntSize to scrollToOffset.

Source/WebKit/win:

  • WebView.cpp:

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

Source/WebKit2:

  • WebProcess/WebPage/win/WebPageWin.cpp:

(WebKit::WebPage::gestureDidScroll):
Updated to pass an IntSize to scrollByRecursively.

Location:
trunk/Source
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r120829 r120832  
     12012-06-20  Julien Chaffraix  <jchaffraix@webkit.org>
     2
     3        Use IntSize in RenderLayer to represent scroll offsets
     4        https://bugs.webkit.org/show_bug.cgi?id=89154
     5
     6        Reviewed by Eric Seidel.
     7
     8        Refactoring, covered by existing tests.
     9
     10        * accessibility/AccessibilityRenderObject.cpp:
     11        (WebCore::AccessibilityRenderObject::scrollTo):
     12        * html/TextFieldInputType.cpp:
     13        (WebCore::TextFieldInputType::forwardEvent):
     14        * page/SpatialNavigation.cpp:
     15        (WebCore::scrollInDirection):
     16        * rendering/RenderMarquee.cpp:
     17        (WebCore::RenderMarquee::start):
     18        Updated those call-sites to use the IntSize variant of the scrolling function.
     19
     20        * rendering/RenderLayer.cpp:
     21        (WebCore::RenderLayer::panScrollFromPoint):
     22        Updated the signature to use IntPoint to avoid an extra round-trip to LayoutPoint
     23        (furthermore touch points should be in device pixels).
     24
     25        (WebCore::RenderLayer::clampScrollOffset):
     26        Added this function that clamps a scroll offset to the box's size. This enables more
     27        code sharing between the different functions. Also removed a NULL-check that shouldn't
     28        be needed: scrolling is a RenderBox concept so any callers should ensure that we have
     29        a RenderBox or it makes no sense to try to scroll.
     30
     31        (WebCore::RenderLayer::updateLayerPosition):
     32        (WebCore::adjustedScrollDelta):
     33        (WebCore::RenderLayer::scrollByRecursively):
     34        (WebCore::RenderLayer::scrollToOffset):
     35        (WebCore::RenderLayer::scrollRectToVisible):
     36        (WebCore::RenderLayer::updateScrollInfoAfterLayout):
     37        Updated to do IntSize arithmetic. Reuse clampScrollOffset when applicable.
     38
     39        * rendering/RenderLayer.h:
     40        (WebCore::RenderLayer::scrollToXOffset):
     41        (WebCore::RenderLayer::scrollToYOffset):
     42        Updated the functions to take IntSize as much as possible.
     43
    1442012-06-20  Alexei Filippov  <alexeif@chromium.org>
    245

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r118478 r120832  
    40144014
    40154015    RenderLayer* layer = box->layer();
    4016     layer->scrollToOffset(point.x(), point.y(), RenderLayer::ScrollOffsetClamped);
     4016    layer->scrollToOffset(toSize(point), RenderLayer::ScrollOffsetClamped);
    40174017}
    40184018

  • trunk/Source/WebCore/html/TextFieldInputType.cpp

    r120695 r120832  
    185185        if (event->type() == eventNames().blurEvent) {
    186186            if (RenderBox* innerTextRenderer = innerTextElement()->renderBox()) {
    187                 if (RenderLayer* innerLayer = innerTextRenderer->layer())
    188                     innerLayer->scrollToOffset(!renderTextControl->style()->isLeftToRightDirection() ? innerLayer->scrollWidth() : 0, 0, RenderLayer::ScrollOffsetClamped);
     187                if (RenderLayer* innerLayer = innerTextRenderer->layer()) {
     188                    IntSize scrollOffset(!renderTextControl->style()->isLeftToRightDirection() ? innerLayer->scrollWidth() : 0, 0);
     189                    innerLayer->scrollToOffset(scrollOffset, RenderLayer::ScrollOffsetClamped);
     190                }
    189191            }
    190192

  • trunk/Source/WebCore/page/SpatialNavigation.cpp

    r115691 r120832  
    400400        }
    401401
    402         container->renderBox()->enclosingLayer()->scrollByRecursively(dx, dy);
     402        container->renderBox()->enclosingLayer()->scrollByRecursively(IntSize(dx, dy));
    403403        return true;
    404404    }

  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r120824 r120832  
    847847        }
    848848
    849         LayoutSize scrollOffset = parent()->scrolledContentOffset();
     849        IntSize scrollOffset = parent()->scrolledContentOffset();
    850850        localPoint -= scrollOffset;
    851851    }
    … …  
    15221522}
    15231523
    1524 void RenderLayer::panScrollFromPoint(const LayoutPoint& sourcePoint)
     1524static inline IntSize adjustedScrollDelta(const IntSize& delta)
     1525{
     1526    return IntSize(adjustedScrollDelta(delta.width()), adjustedScrollDelta(delta.height()));
     1527}
     1528
     1529void RenderLayer::panScrollFromPoint(const IntPoint& sourcePoint)
    15251530{
    15261531    Frame* frame = renderer()->frame();
    … …  
    15371542        previousMousePosition = currentMousePosition;
    15381543
    1539     int xDelta = currentMousePosition.x() - sourcePoint.x();
    1540     int yDelta = currentMousePosition.y() - sourcePoint.y();
    1541 
    1542     if (abs(xDelta) <= ScrollView::noPanScrollRadius) // at the center we let the space for the icon
    1543         xDelta = 0;
    1544     if (abs(yDelta) <= ScrollView::noPanScrollRadius)
    1545         yDelta = 0;
    1546 
    1547     scrollByRecursively(adjustedScrollDelta(xDelta), adjustedScrollDelta(yDelta), ScrollOffsetClamped);
    1548 }
    1549 
    1550 void RenderLayer::scrollByRecursively(int xDelta, int yDelta, ScrollOffsetClamping clamp)
    1551 {
    1552     if (!xDelta && !yDelta)
     1544    IntSize delta = currentMousePosition - sourcePoint;
     1545
     1546    if (abs(delta.width()) <= ScrollView::noPanScrollRadius) // at the center we let the space for the icon
     1547        delta.setWidth(0);
     1548    if (abs(delta.height()) <= ScrollView::noPanScrollRadius)
     1549        delta.setHeight(0);
     1550
     1551    scrollByRecursively(adjustedScrollDelta(delta), ScrollOffsetClamped);
     1552}
     1553
     1554void RenderLayer::scrollByRecursively(const IntSize& delta, ScrollOffsetClamping clamp)
     1555{
     1556    if (delta.isZero())
    15531557        return;
    15541558
    … …  
    15581562
    15591563    if (renderer()->hasOverflowClip() && !restrictedByLineClamp) {
    1560         int newOffsetX = scrollXOffset() + xDelta;
    1561         int newOffsetY = scrollYOffset() + yDelta;
    1562         scrollToOffset(newOffsetX, newOffsetY, clamp);
     1564        IntSize newScrollOffset = scrollOffset() + delta;
     1565        scrollToOffset(newScrollOffset, clamp);
    15631566
    15641567        // If this layer can't do the scroll we ask the next layer up that can scroll to try
    1565         int leftToScrollX = newOffsetX - scrollXOffset();
    1566         int leftToScrollY = newOffsetY - scrollYOffset();
    1567         if ((leftToScrollX || leftToScrollY) && renderer()->parent()) {
     1568        IntSize remainingScrollOffset = newScrollOffset - scrollOffset();
     1569        if (!remainingScrollOffset.isZero() && renderer()->parent()) {
    15681570            if (RenderLayer* scrollableLayer = enclosingScrollableLayer())
    1569                 scrollableLayer->scrollByRecursively(leftToScrollX, leftToScrollY);
     1571                scrollableLayer->scrollByRecursively(remainingScrollOffset);
    15701572
    15711573            Frame* frame = renderer()->frame();
    … …  
    15761578        // If we are here, we were called on a renderer that can be programmatically scrolled, but doesn't
    15771579        // have an overflow clip. Which means that it is a document node that can be scrolled.
    1578         renderer()->view()->frameView()->scrollBy(IntSize(xDelta, yDelta));
     1580        renderer()->view()->frameView()->scrollBy(delta);
    15791581        // FIXME: If we didn't scroll the whole way, do we want to try looking at the frames ownerElement?
    15801582        // https://bugs.webkit.org/show_bug.cgi?id=28237
    … …  
    15821584}
    15831585
    1584 void RenderLayer::scrollToOffset(int x, int y, ScrollOffsetClamping clamp)
    1585 {
    1586     if (clamp == ScrollOffsetClamped) {
    1587         RenderBox* box = renderBox();
    1588         if (!box)
    1589             return;
    1590 
    1591         int maxX = scrollWidth() - box->clientWidth();
    1592         int maxY = scrollHeight() - box->clientHeight();
    1593 
    1594         x = min(max(x, 0), maxX);
    1595         y = min(max(y, 0), maxY);
    1596     }
    1597 
    1598     IntPoint newScrollOffset(x, y);
    1599     if (newScrollOffset != LayoutPoint(scrollXOffset(), scrollYOffset()))
    1600         scrollToOffsetWithoutAnimation(newScrollOffset);
     1586IntSize RenderLayer::clampScrollOffset(const IntSize& scrollOffset) const
     1587{
     1588    RenderBox* box = renderBox();
     1589    ASSERT(box);
     1590
     1591    int maxX = scrollWidth() - box->clientWidth();
     1592    int maxY = scrollHeight() - box->clientHeight();
     1593
     1594    int x = min(max(scrollOffset.width(), 0), maxX);
     1595    int y = min(max(scrollOffset.height(), 0), maxY);
     1596    return IntSize(x, y);
     1597}
     1598
     1599void RenderLayer::scrollToOffset(const IntSize& scrollOffset, ScrollOffsetClamping clamp)
     1600{
     1601    IntSize newScrollOffset = clamp == ScrollOffsetClamped ? clampScrollOffset(scrollOffset) : scrollOffset;
     1602    if (newScrollOffset != this->scrollOffset())
     1603        scrollToOffsetWithoutAnimation(toPoint(newScrollOffset));
    16011604}
    16021605
    … …  
    16931696        LayoutRect r = getRectToExpose(layerBounds, exposeRect, alignX, alignY);
    16941697       
    1695         LayoutUnit adjustedX = r.x() - absPos.x();
    1696         LayoutUnit adjustedY = r.y() - absPos.y();
    1697         // Adjust offsets if they're outside of the allowable range.
    1698         adjustedX = max<LayoutUnit>(0, min(scrollWidth() - layerBounds.width(), adjustedX));
    1699         adjustedY = max<LayoutUnit>(0, min(scrollHeight() - layerBounds.height(), adjustedY));
    1700 
    1701         int xOffset = roundToInt(adjustedX);
    1702         int yOffset = roundToInt(adjustedY);
    1703        
    1704         if (xOffset != scrollXOffset() || yOffset != scrollYOffset()) {
    1705             int diffX = scrollXOffset();
    1706             int diffY = scrollYOffset();
    1707             scrollToOffset(xOffset, yOffset);
    1708             diffX = scrollXOffset() - diffX;
    1709             diffY = scrollYOffset() - diffY;
    1710             newRect.setX(rect.x() - diffX);
    1711             newRect.setY(rect.y() - diffY);
     1698        int roundedAdjustedX = roundToInt(r.x() - absPos.x());
     1699        int roundedAdjustedY = roundToInt(r.y() - absPos.y());
     1700        IntSize clampedScrollOffset = clampScrollOffset(IntSize(roundedAdjustedX, roundedAdjustedY));
     1701        if (clampedScrollOffset != scrollOffset()) {
     1702            IntSize oldScrollOffset = scrollOffset();
     1703            scrollToOffset(clampedScrollOffset);
     1704            IntSize scrollOffsetDifference = scrollOffset() - oldScrollOffset;
     1705            newRect.move(-scrollOffsetDifference);
    17121706        }
    17131707    } else if (!parentLayer && renderer()->isBox() && renderBox()->canBeProgramaticallyScrolled()) {
    … …  
    25622556
    25632557    m_scrollDimensionsDirty = true;
    2564     IntSize scrollOffsetOriginal(scrollXOffset(), scrollYOffset());
     2558    IntSize originalScrollOffset = scrollOffset();
    25652559
    25662560    computeScrollDimensions();
    … …  
    25692563        // Layout may cause us to be at an invalid scroll position. In this case we need
    25702564        // to pull our scroll offsets back to the max (or push them up to the min).
    2571         int newX = max(0, min<int>(scrollXOffset(), scrollWidth() - box->clientWidth()));
    2572         int newY = max(0, min<int>(scrollYOffset(), scrollHeight() - box->clientHeight()));
    2573         if (newX != scrollXOffset() || newY != scrollYOffset())
    2574             scrollToOffset(newX, newY);
     2565        IntSize clampedScrollOffset = clampScrollOffset(scrollOffset());
     2566        if (clampedScrollOffset != scrollOffset())
     2567            scrollToOffset(clampedScrollOffset);
    25752568    }
    25762569
    25772570    updateScrollbarsAfterLayout();
    25782571
    2579     if (scrollOffsetOriginal != scrollOffset())
    2580         scrollToOffsetWithoutAnimation(IntPoint(scrollXOffset(), scrollYOffset()));
     2572    if (originalScrollOffset != scrollOffset())
     2573        scrollToOffsetWithoutAnimation(toPoint(scrollOffset()));
    25812574}
    25822575

  • trunk/Source/WebCore/rendering/RenderLayer.h

    r120824 r120832  
    310310    int scrollHeight() const;
    311311
    312     void panScrollFromPoint(const LayoutPoint&);
     312    void panScrollFromPoint(const IntPoint&);
    313313
    314314    enum ScrollOffsetClamping {
    … …  
    318318
    319319    // Scrolling methods for layers that can scroll their overflow.
    320     void scrollByRecursively(int xDelta, int yDelta, ScrollOffsetClamping = ScrollOffsetUnclamped);
     320    void scrollByRecursively(const IntSize&, ScrollOffsetClamping = ScrollOffsetUnclamped);
     321    void scrollToOffset(const IntSize&, ScrollOffsetClamping = ScrollOffsetUnclamped);
     322    void scrollToXOffset(int x, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(IntSize(x, scrollYOffset()), clamp); }
     323    void scrollToYOffset(int y, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(IntSize(scrollXOffset(), y), clamp); }
    321324
    322325    int scrollXOffset() const { return m_scrollOffset.width() + scrollOrigin().x(); }
    323326    int scrollYOffset() const { return m_scrollOffset.height() + scrollOrigin().y(); }
    324327    IntSize scrollOffset() const { return IntSize(scrollXOffset(), scrollYOffset()); }
    325 
    326     void scrollToOffset(int, int, ScrollOffsetClamping = ScrollOffsetUnclamped);
    327     void scrollToXOffset(int x, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(x, scrollYOffset(), clamp); }
    328     void scrollToYOffset(int y, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(scrollXOffset(), y, clamp); }
    329328
    330329    void scrollRectToVisible(const LayoutRect&, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
    … …  
    678677    friend IntSize RenderBox::scrolledContentOffset() const;
    679678    IntSize scrolledContentOffset() const { return m_scrollOffset; }
     679
     680    IntSize clampScrollOffset(const IntSize&) const;
    680681
    681682    // The normal operator new is disallowed on all render objects.

  • trunk/Source/WebCore/rendering/RenderMarquee.cpp

    r120495 r120832  
    168168    if (!m_suspended && !m_stopped) {
    169169        if (isHorizontal())
    170             m_layer->scrollToOffset(m_start, 0);
     170            m_layer->scrollToOffset(IntSize(m_start, 0));
    171171        else
    172             m_layer->scrollToOffset(0, m_start);
     172            m_layer->scrollToOffset(IntSize(0, m_start));
    173173    }
    174174    else {

  • trunk/Source/WebKit/blackberry/Api/WebPage.cpp

    r120774 r120832  
    43454345            m_inRegionScrollStartingNode = enclosingLayerNode(layer);
    43464346            IntPoint newOffset = currentOffset + layerDelta;
    4347             layer->scrollToOffset(newOffset.x(), newOffset.y());
     4347            layer->scrollToOffset(toSize(newOffset));
    43484348            renderer->repaint(true);
    43494349            return true;

  • trunk/Source/WebKit/blackberry/ChangeLog

    r120774 r120832  
     12012-06-20  Julien Chaffraix  <jchaffraix@webkit.org>
     2
     3        Use IntSize in RenderLayer to represent scroll offsets
     4        https://bugs.webkit.org/show_bug.cgi?id=89154
     5
     6        Reviewed by Eric Seidel.
     7
     8        * Api/WebPage.cpp:
     9        (BlackBerry::WebKit::WebPagePrivate::scrollRenderer):
     10        Updated to pass an IntSize to scrollToOffset.
     11
    1122012-06-19  Yong Li  <yoli@rim.com>
    213

  • trunk/Source/WebKit/win/ChangeLog

    r120054 r120832  
     12012-06-20  Julien Chaffraix  <jchaffraix@webkit.org>
     2
     3        Use IntSize in RenderLayer to represent scroll offsets
     4        https://bugs.webkit.org/show_bug.cgi?id=89154
     5
     6        Reviewed by Eric Seidel.
     7
     8        * WebView.cpp:
     9        (WebView::gesture):
     10        Updated to pass an IntSize to scrollByRecursively.
     11
    1122012-06-11  Kaustubh Atrawalkar  <kaustubh@motorola.com>
    213

  • trunk/Source/WebKit/win/WebView.cpp

    r118594 r120832  
    16531653
    16541654        // We negate here since panning up moves the content up, but moves the scrollbar down.
    1655         m_gestureTargetNode->renderer()->enclosingLayer()->scrollByRecursively(-deltaX, -deltaY);
     1655        m_gestureTargetNode->renderer()->enclosingLayer()->scrollByRecursively(IntSize(-deltaX, -deltaY));
    16561656           
    16571657        if (!(UpdatePanningFeedbackPtr() && BeginPanningFeedbackPtr() && EndPanningFeedbackPtr())) {

  • trunk/Source/WebKit2/ChangeLog

    r120831 r120832  
     12012-06-20  Julien Chaffraix  <jchaffraix@webkit.org>
     2
     3        Use IntSize in RenderLayer to represent scroll offsets
     4        https://bugs.webkit.org/show_bug.cgi?id=89154
     5
     6        Reviewed by Eric Seidel.
     7
     8        * WebProcess/WebPage/win/WebPageWin.cpp:
     9        (WebKit::WebPage::gestureDidScroll):
     10        Updated to pass an IntSize to scrollByRecursively.
     11
    1122012-06-20  Christophe Dumez  <christophe.dumez@intel.com>
    213

  • trunk/Source/WebKit2/WebProcess/WebPage/win/WebPageWin.cpp

    r95901 r120832  
    448448    }
    449449
    450     m_gestureTargetNode->renderer()->enclosingLayer()->scrollByRecursively(size.width(), size.height());
     450    m_gestureTargetNode->renderer()->enclosingLayer()->scrollByRecursively(size);
    451451    bool gestureReachedScrollingLimit = verticalScrollbar && scrollbarAtTopOrBottomOfDocument(verticalScrollbar);
    452452
Note: See TracChangeset for help on using the changeset viewer.