2011-05-10 Emil A Eklund <eae@chromium.org>
authoreae@chromium.org <eae@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 May 2011 00:06:35 +0000 (00:06 +0000)
committereae@chromium.org <eae@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 May 2011 00:06:35 +0000 (00:06 +0000)
        Reviewed by Eric Seidel.

        Convert x,y and width,height pairs to IntPoint and IntSize for RenderLayer
        https://bugs.webkit.org/show_bug.cgi?id=60409

        Convert RenderLayer to use IntPoint for x,y pairs and IntSize for offsets and sizes.

        Refactoring, covered by existing tests.

        * rendering/RenderLayer.cpp:
        (WebCore::RenderLayer::RenderLayer):
        (WebCore::RenderLayer::updateLayerPositions):
        (WebCore::RenderLayer::updateLayerPosition):
        (WebCore::RenderLayer::scrollTo):
        (WebCore::RenderLayer::visibleHeight):
        (WebCore::RenderLayer::visibleWidth):
        (WebCore::RenderLayer::scrollWidth):
        (WebCore::RenderLayer::scrollHeight):
        (WebCore::RenderLayer::computeScrollDimensions):
        (WebCore::RenderLayer::updateScrollInfoAfterLayout):
        * rendering/RenderLayer.h:
        (WebCore::RenderLayer::x):
        (WebCore::RenderLayer::y):
        (WebCore::RenderLayer::setLocation):
        (WebCore::RenderLayer::width):
        (WebCore::RenderLayer::height):
        (WebCore::RenderLayer::size):
        (WebCore::RenderLayer::setWidth):
        (WebCore::RenderLayer::setHeight):
        (WebCore::RenderLayer::scrolledContentOffset):
        (WebCore::RenderLayer::scrollXOffset):
        (WebCore::RenderLayer::scrollYOffset):
        (WebCore::RenderLayer::scrollOffset):
        (WebCore::RenderLayer::scrollToXOffset):
        (WebCore::RenderLayer::scrollToYOffset):
        (WebCore::RenderLayer::relativePositionOffset):

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

Source/WebCore/ChangeLog
Source/WebCore/rendering/RenderLayer.cpp
Source/WebCore/rendering/RenderLayer.h

index 188d436..72f0bd4 100644 (file)
@@ -1,3 +1,42 @@
+2011-05-10  Emil A Eklund  <eae@chromium.org>
+
+        Reviewed by Eric Seidel.
+
+        Convert x,y and width,height pairs to IntPoint and IntSize for RenderLayer
+        https://bugs.webkit.org/show_bug.cgi?id=60409
+
+        Convert RenderLayer to use IntPoint for x,y pairs and IntSize for offsets and sizes.
+
+        Refactoring, covered by existing tests.
+
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::RenderLayer):
+        (WebCore::RenderLayer::updateLayerPositions):
+        (WebCore::RenderLayer::updateLayerPosition):
+        (WebCore::RenderLayer::scrollTo):
+        (WebCore::RenderLayer::visibleHeight):
+        (WebCore::RenderLayer::visibleWidth):
+        (WebCore::RenderLayer::scrollWidth):
+        (WebCore::RenderLayer::scrollHeight):
+        (WebCore::RenderLayer::computeScrollDimensions):
+        (WebCore::RenderLayer::updateScrollInfoAfterLayout):
+        * rendering/RenderLayer.h:
+        (WebCore::RenderLayer::x):
+        (WebCore::RenderLayer::y):
+        (WebCore::RenderLayer::setLocation):
+        (WebCore::RenderLayer::width):
+        (WebCore::RenderLayer::height):
+        (WebCore::RenderLayer::size):
+        (WebCore::RenderLayer::setWidth):
+        (WebCore::RenderLayer::setHeight):
+        (WebCore::RenderLayer::scrolledContentOffset):
+        (WebCore::RenderLayer::scrollXOffset):
+        (WebCore::RenderLayer::scrollYOffset):
+        (WebCore::RenderLayer::scrollOffset):
+        (WebCore::RenderLayer::scrollToXOffset):
+        (WebCore::RenderLayer::scrollToYOffset):
+        (WebCore::RenderLayer::relativePositionOffset):
+
 2011-05-10  Levi Weintraub  <leviw@chromium.org>
 
         Reviewed by Eric Seidel.
index 10b3e30..71b4739 100644 (file)
@@ -135,18 +135,6 @@ RenderLayer::RenderLayer(RenderBoxModelObject* renderer)
     , m_next(0)
     , m_first(0)
     , m_last(0)
-    , m_relX(0)
-    , m_relY(0)
-    , m_x(0)
-    , m_y(0)
-    , m_width(0)
-    , m_height(0)
-    , m_scrollX(0)
-    , m_scrollY(0)
-    , m_scrollLeftOverflow(0)
-    , m_scrollTopOverflow(0)
-    , m_scrollWidth(0)
-    , m_scrollHeight(0)
     , m_inResizeMode(false)
     , m_posZOrderList(0)
     , m_negZOrderList(0)
@@ -282,10 +270,10 @@ void RenderLayer::updateLayerPositions(UpdateLayerPositionsFlags flags, IntPoint
         else {
             oldCachedOffset = *cachedOffset;
             // Frequently our parent layer's renderer will be the same as our renderer's containing block.  In that case,
-            // we just update the cache using our offset to our parent (which is m_x / m_y).  Otherwise, regenerated cached
+            // we just update the cache using our offset to our parent (which is m_topLeft). Otherwise, regenerated cached
             // offsets to the root from the render tree.
             if (!m_parent || m_parent->renderer() == renderer()->containingBlock())
-                cachedOffset->move(m_x, m_y); // Fast case
+                cachedOffset->move(m_topLeft.x(), m_topLeft.y()); // Fast case
             else {
                 int x = 0;
                 int y = 0;
@@ -719,11 +707,11 @@ void RenderLayer::updateLayerPosition()
         localPoint -= scrollOffset;
     }
         
-    m_relX = m_relY = 0;
     if (renderer()->isRelPositioned()) {
-        m_relX = renderer()->relativePositionOffsetX();
-        m_relY = renderer()->relativePositionOffsetY();
-        localPoint.move(m_relX, m_relY);
+        m_relativeOffset = renderer()->relativePositionOffset();
+        localPoint.move(m_relativeOffset);
+    } else {
+        m_relativeOffset = IntSize();
     }
 
     // FIXME: We'd really like to just get rid of the concept of a layer rectangle and rely on the renderers.
@@ -1338,12 +1326,10 @@ 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.).
-    int newScrollX = x - m_scrollOrigin.x();
-    int newScrollY = y - m_scrollOrigin.y();
-    if (m_scrollY == newScrollY && m_scrollX == newScrollX)
+    IntSize newScrollOffset = IntSize(x - m_scrollOrigin.x(), y - m_scrollOrigin.y());
+    if (m_scrollOffset == newScrollOffset)
         return;
-    m_scrollX = newScrollX;
-    m_scrollY = newScrollY;
+    m_scrollOffset = newScrollOffset;
 
     // Update the positions of our child layers. Don't have updateLayerPositions() update
     // compositing layers, because we need to do a deep update from the compositing ancestor.
@@ -1786,12 +1772,12 @@ IntSize RenderLayer::contentsSize() const
 
 int RenderLayer::visibleHeight() const
 {
-    return m_height;
+    return m_layerSize.height();
 }
 
 int RenderLayer::visibleWidth() const
 {
-    return m_width;
+    return m_layerSize.width();
 }
 
 bool RenderLayer::shouldSuspendScrollAnimations() const
@@ -2036,14 +2022,14 @@ int RenderLayer::scrollWidth()
 {
     if (m_scrollDimensionsDirty)
         computeScrollDimensions();
-    return m_scrollWidth;
+    return m_scrollSize.width();
 }
 
 int RenderLayer::scrollHeight()
 {
     if (m_scrollDimensionsDirty)
         computeScrollDimensions();
-    return m_scrollHeight;
+    return m_scrollSize.height();
 }
 
 int RenderLayer::overflowTop() const
@@ -2085,18 +2071,18 @@ void RenderLayer::computeScrollDimensions(bool* needHBar, bool* needVBar)
     
     m_scrollDimensionsDirty = false;
 
-    m_scrollLeftOverflow = overflowLeft() - box->borderLeft();
-    m_scrollTopOverflow = overflowTop() - box->borderTop();
+    m_scrollOverflow.setWidth(overflowLeft() - box->borderLeft());
+    m_scrollOverflow.setHeight(overflowTop() - box->borderTop());
 
-    m_scrollWidth = overflowRight() - overflowLeft();
-    m_scrollHeight = overflowBottom() - overflowTop();
+    m_scrollSize.setWidth(overflowRight() - overflowLeft());
+    m_scrollSize.setHeight(overflowBottom() - overflowTop());
     
-    m_scrollOrigin = IntPoint(-m_scrollLeftOverflow, -m_scrollTopOverflow);
+    m_scrollOrigin = IntPoint(-m_scrollOverflow.width(), -m_scrollOverflow.height());
 
     if (needHBar)
-        *needHBar = m_scrollWidth > box->clientWidth();
+        *needHBar = m_scrollSize.width() > box->clientWidth();
     if (needVBar)
-        *needVBar = m_scrollHeight > box->clientHeight();
+        *needVBar = m_scrollSize.height() > box->clientHeight();
 }
 
 void RenderLayer::updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow)
@@ -2213,13 +2199,13 @@ void RenderLayer::updateScrollInfoAfterLayout()
         int clientWidth = box->clientWidth();
         int pageStep = max(max<int>(clientWidth * Scrollbar::minFractionToStepWhenPaging(), clientWidth - Scrollbar::maxOverlapBetweenPages()), 1);
         m_hBar->setSteps(Scrollbar::pixelsPerLineStep(), pageStep);
-        m_hBar->setProportion(clientWidth, m_scrollWidth);
+        m_hBar->setProportion(clientWidth, m_scrollSize.width());
     }
     if (m_vBar) {
         int clientHeight = box->clientHeight();
         int pageStep = max(max<int>(clientHeight * Scrollbar::minFractionToStepWhenPaging(), clientHeight - Scrollbar::maxOverlapBetweenPages()), 1);
         m_vBar->setSteps(Scrollbar::pixelsPerLineStep(), pageStep);
-        m_vBar->setProportion(clientHeight, m_scrollHeight);
+        m_vBar->setProportion(clientHeight, m_scrollSize.height());
     }
  
     RenderView* view = renderer()->view();
index 11029ed..c51d2a3 100644 (file)
@@ -211,20 +211,19 @@ public:
         return curr;
     }
     
-    int x() const { return m_x; }
-    int y() const { return m_y; }
+    int x() const { return m_topLeft.x(); }
+    int y() const { return m_topLeft.y(); }
     void setLocation(int x, int y)
     {
-        m_x = x;
-        m_y = y;
+        m_topLeft = IntPoint(x, y);
     }
 
-    int width() const { return m_width; }
-    int height() const { return m_height; }
-    IntSize size() const { return IntSize(m_width, m_height); }
+    int width() const { return m_layerSize.width(); }
+    int height() const { return m_layerSize.height(); }
+    const IntSize& size() const { return m_layerSize; }
     
-    void setWidth(int w) { m_width = w; }
-    void setHeight(int h) { m_height = h; }
+    void setWidth(int w) { m_layerSize.setWidth(w); }
+    void setHeight(int h) { m_layerSize.setHeight(h); }
 
     int scrollWidth();
     int scrollHeight();
@@ -234,14 +233,15 @@ public:
     // Scrolling methods for layers that can scroll their overflow.
     void scrollByRecursively(int xDelta, int yDelta);
 
-    IntSize scrolledContentOffset() const { return IntSize(scrollXOffset() + m_scrollLeftOverflow, scrollYOffset() + m_scrollTopOverflow); }
+    IntSize scrolledContentOffset() const { return scrollOffset() + m_scrollOverflow; }
 
-    int scrollXOffset() const { return m_scrollX + m_scrollOrigin.x(); }
-    int scrollYOffset() const { return m_scrollY + m_scrollOrigin.y(); }
+    int scrollXOffset() const { return m_scrollOffset.width() + m_scrollOrigin.x(); }
+    int scrollYOffset() const { return m_scrollOffset.height() + m_scrollOrigin.y(); }
+    IntSize scrollOffset() const { return IntSize(scrollXOffset(), scrollYOffset()); }
 
     void scrollToOffset(int x, int y);
-    void scrollToXOffset(int x) { scrollToOffset(x, m_scrollY + m_scrollOrigin.y()); }
-    void scrollToYOffset(int y) { scrollToOffset(m_scrollX + m_scrollOrigin.x(), y); }
+    void scrollToXOffset(int x) { scrollToOffset(x, scrollYOffset()); }
+    void scrollToYOffset(int y) { scrollToOffset(scrollXOffset(), y); }
     void scrollRectToVisible(const IntRect&, bool scrollToAnchor = false, const ScrollAlignment& alignX = ScrollAlignment::alignCenterIfNeeded, const ScrollAlignment& alignY = ScrollAlignment::alignCenterIfNeeded);
 
     IntRect getRectToExpose(const IntRect& visibleRect, const IntRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
@@ -307,8 +307,8 @@ public:
 
     void updateTransform();
 
-    void relativePositionOffset(int& relX, int& relY) const { relX += m_relX; relY += m_relY; }
-    IntSize relativePositionOffset() const { return IntSize(m_relX, m_relY); }
+    void relativePositionOffset(int& relX, int& relY) const { relX += m_relativeOffset.width(); relY += m_relativeOffset.height(); }
+    const IntSize& relativePositionOffset() const { return m_relativeOffset; }
 
     void clearClipRectsIncludingDescendants();
     void clearClipRects();
@@ -623,27 +623,21 @@ protected:
     IntRect m_outlineBox;
 
     // Our current relative position offset.
-    int m_relX;
-    int m_relY;
+    IntSize m_relativeOffset;
 
     // Our (x,y) coordinates are in our parent layer's coordinate space.
-    int m_x;
-    int m_y;
+    IntPoint m_topLeft;
 
     // The layer's width/height
-    int m_width;
-    int m_height;
+    IntSize m_layerSize;
 
     // Our scroll offsets if the view is scrolled.
-    int m_scrollX;
-    int m_scrollY;
-    
-    int m_scrollLeftOverflow;
-    int m_scrollTopOverflow;
+    IntSize m_scrollOffset;
+
+    IntSize m_scrollOverflow;
     
     // The width/height of our scrolled area.
-    int m_scrollWidth;
-    int m_scrollHeight;
+    IntSize m_scrollSize;
 
     // For layers with overflow, we have a pair of scrollbars.
     RefPtr<Scrollbar> m_hBar;