Changeset 93429 in webkit

Timestamp:

Aug 19, 2011 12:26:03 PM (13 years ago)

Author:

eae@chromium.org

Message:

Switch RenderLayer to to new layout types
​https://bugs.webkit.org/show_bug.cgi?id=66507

Reviewed by Eric Seidel.

Convert RenderLayer to new layout abstraction.

No new tests as no new functionality.

• rendering/LayoutTypes.h:

(WebCore::flooredLayoutSize):

• rendering/RenderLayer.cpp:
• rendering/RenderLayer.h:
• rendering/RenderLayerBacking.cpp:
• rendering/RenderLayerBacking.h:
• rendering/RenderLayerCompositor.cpp:
• rendering/RenderLayerCompositor.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• rendering/LayoutTypes.h (modified) (1 diff)
• rendering/RenderLayer.cpp (modified) (109 diffs)
• rendering/RenderLayer.h (modified) (20 diffs)
• rendering/RenderLayerBacking.cpp (modified) (29 diffs)
• rendering/RenderLayerBacking.h (modified) (7 diffs)
• rendering/RenderLayerCompositor.cpp (modified) (31 diffs)
• rendering/RenderLayerCompositor.h (modified) (5 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-08-19  Emil A Eklund  <eae@chromium.org>
+
+        Switch RenderLayer to to new layout types
+        https://bugs.webkit.org/show_bug.cgi?id=66507
+
+        Reviewed by Eric Seidel.
+
+        Convert RenderLayer to new layout abstraction.
+
+        No new tests as no new functionality.
+
+        * rendering/LayoutTypes.h:
+        (WebCore::flooredLayoutSize):
+        * rendering/RenderLayer.cpp:
+        * rendering/RenderLayer.h:
+        * rendering/RenderLayerBacking.cpp:
+        * rendering/RenderLayerBacking.h:
+        * rendering/RenderLayerCompositor.cpp:
+        * rendering/RenderLayerCompositor.h:
+
 2011-08-19  Mihnea Ovidenie  <mihnea@adobe.com>
 

trunk/Source/WebCore/rendering/LayoutTypes.h

@@ -72 +72 @@
 }
 
+inline LayoutSize flooredLayoutSize(const FloatPoint& p)
+{
+    return LayoutSize(static_cast<int>(p.x()), static_cast<int>(p.y()));
+}
+
 inline LayoutUnit roundedLayoutUnit(float value)
 {

trunk/Source/WebCore/rendering/RenderLayer.cpp

@@ -254 +254 @@
 }
 
-void RenderLayer::updateLayerPositions(UpdateLayerPositionsFlags flags, IntPoint* cachedOffset)
+void RenderLayer::updateLayerPositions(UpdateLayerPositionsFlags flags, LayoutPoint* cachedOffset)
 {
     updateLayerPosition(); // For relpositioned layers or non-positioned layers,
                            // we need to keep in sync, since we may have shifted relative
                            // to our parent layer.
-    IntPoint oldCachedOffset;
+    LayoutPoint oldCachedOffset;
     if (cachedOffset) {
         // We can't cache our offset to the repaint container if the mapping is anything more complex than a simple translation
@@ -276 +276 @@
                 cachedOffset->move(m_topLeft.x(), m_topLeft.y()); // Fast case
             else {
-                IntPoint offset;
+                LayoutPoint offset;
                 convertToLayerCoords(root(), offset);
                 *cachedOffset = offset;
@@ -283 +283 @@
     }
 
-    IntPoint offset;
+    LayoutPoint offset;
     if (cachedOffset) {
         offset = *cachedOffset;
 #ifndef NDEBUG
-        IntPoint nonCachedOffset;
+        LayoutPoint nonCachedOffset;
         convertToLayerCoords(root(), nonCachedOffset);
         ASSERT(offset == nonCachedOffset);
@@ -310 +310 @@
 
         RenderBoxModelObject* repaintContainer = renderer()->containerForRepaint();
-        IntRect newRect = renderer()->clippedOverflowRectForRepaint(repaintContainer);
-        IntRect newOutlineBox = renderer()->outlineBoundsForRepaint(repaintContainer, cachedOffset);
+        LayoutRect newRect = renderer()->clippedOverflowRectForRepaint(repaintContainer);
+        LayoutRect newOutlineBox = renderer()->outlineBoundsForRepaint(repaintContainer, cachedOffset);
         // FIXME: Should ASSERT that value calculated for newOutlineBox using the cached offset is the same
         // as the value not using the cached offset, but we can't due to https://bugs.webkit.org/show_bug.cgi?id=37048
@@ -327 +327 @@
         m_outlineBox = newOutlineBox;
     } else {
-        m_repaintRect = IntRect();
-        m_outlineBox = IntRect();
+        m_repaintRect = LayoutRect();
+        m_outlineBox = LayoutRect();
     }
 
@@ -363 +363 @@
 }
 
-IntRect RenderLayer::repaintRectIncludingDescendants() const
-{
-    IntRect repaintRect = m_repaintRect;
+LayoutRect RenderLayer::repaintRectIncludingDescendants() const
+{
+    LayoutRect repaintRect = m_repaintRect;
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
         repaintRect.unite(child->repaintRectIncludingDescendants());
@@ -642 +642 @@
 void RenderLayer::updateLayerPosition()
 {
-    IntPoint localPoint;
-    IntSize inlineBoundingBoxOffset; // We don't put this into the RenderLayer x/y for inlines, so we need to subtract it out when done.
+    LayoutPoint localPoint;
+    LayoutSize inlineBoundingBoxOffset; // We don't put this into the RenderLayer x/y for inlines, so we need to subtract it out when done.
     if (renderer()->isRenderInline()) {
         RenderInline* inlineFlow = toRenderInline(renderer());
-        IntRect lineBox = inlineFlow->linesBoundingBox();
+        LayoutRect lineBox = inlineFlow->linesBoundingBox();
         setSize(lineBox.size());
         inlineBoundingBoxOffset = toSize(lineBox.location());
@@ -681 +681 @@
 
         // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.
-        IntSize offset = positionedParent->scrolledContentOffset();
+        LayoutSize offset = positionedParent->scrolledContentOffset();
         localPoint -= offset;
         
         if (renderer()->isPositioned() && positionedParent->renderer()->isRelPositioned() && positionedParent->renderer()->isRenderInline()) {
-            IntSize offset = toRenderInline(positionedParent->renderer())->relativePositionedInlineOffset(toRenderBox(renderer()));
+            LayoutSize offset = toRenderInline(positionedParent->renderer())->relativePositionedInlineOffset(toRenderBox(renderer()));
             localPoint += offset;
         }
@@ -692 +692 @@
             // FIXME: Composited layers ignore pagination, so about the best we can do is make sure they're offset into the appropriate column.
             // They won't split across columns properly.
-            IntSize columnOffset;
+            LayoutSize columnOffset;
             parent()->renderer()->adjustForColumns(columnOffset, localPoint);
             localPoint += columnOffset;
         }
 
-        IntSize scrollOffset = parent()->scrolledContentOffset();
+        LayoutSize scrollOffset = parent()->scrolledContentOffset();
         localPoint -= scrollOffset;
     }
@@ -705 +705 @@
         localPoint.move(m_relativeOffset);
     } else {
-        m_relativeOffset = IntSize();
+        m_relativeOffset = LayoutSize();
     }
 
@@ -723 +723 @@
 
     // Maybe fetch the perspective from the backing?
-    const IntRect borderBox = toRenderBox(renderer())->borderBoxRect();
+    const LayoutRect borderBox = toRenderBox(renderer())->borderBoxRect();
     const float boxWidth = borderBox.width();
     const float boxHeight = borderBox.height();
@@ -748 +748 @@
         return FloatPoint();
 
-    const IntRect borderBox = toRenderBox(renderer())->borderBoxRect();
+    const LayoutRect borderBox = toRenderBox(renderer())->borderBoxRect();
     RenderStyle* style = renderer()->style();
 
@@ -849 +849 @@
 }
 
-IntPoint RenderLayer::absoluteToContents(const IntPoint& absolutePoint) const
+LayoutPoint RenderLayer::absoluteToContents(const LayoutPoint& absolutePoint) const
 {
     // We don't use convertToLayerCoords because it doesn't know about transforms
-    return roundedIntPoint(renderer()->absoluteToLocal(absolutePoint, false, true));
+    return roundedLayoutPoint(renderer()->absoluteToLocal(absolutePoint, false, true));
 }
 
@@ -887 +887 @@
 }
 
-static IntRect transparencyClipBox(const RenderLayer* l, const RenderLayer* rootLayer, PaintBehavior paintBehavior);
-
-static void expandClipRectForDescendantsAndReflection(IntRect& clipRect, const RenderLayer* l, const RenderLayer* rootLayer, PaintBehavior paintBehavior)
+static LayoutRect transparencyClipBox(const RenderLayer*, const RenderLayer* rootLayer, PaintBehavior);
+
+static void expandClipRectForDescendantsAndReflection(LayoutRect& clipRect, const RenderLayer* layer, const RenderLayer* rootLayer, PaintBehavior paintBehavior)
 {
     // If we have a mask, then the clip is limited to the border box area (and there is
     // no need to examine child layers).
-    if (!l->renderer()->hasMask()) {
+    if (!layer->renderer()->hasMask()) {
         // Note: we don't have to walk z-order lists since transparent elements always establish
         // a stacking context.  This means we can just walk the layer tree directly.
-        for (RenderLayer* curr = l->firstChild(); curr; curr = curr->nextSibling()) {
-            if (!l->reflection() || l->reflectionLayer() != curr)
+        for (RenderLayer* curr = layer->firstChild(); curr; curr = curr->nextSibling()) {
+            if (!layer->reflection() || layer->reflectionLayer() != curr)
                 clipRect.unite(transparencyClipBox(curr, rootLayer, paintBehavior));
         }
@@ -906 +906 @@
     // FIXME: Accelerated compositing will eventually want to do something smart here to avoid incorporating this
     // size into the parent layer.
-    if (l->renderer()->hasReflection()) {
-        IntPoint delta;
-        l->convertToLayerCoords(rootLayer, delta);
+    if (layer->renderer()->hasReflection()) {
+        LayoutPoint delta;
+        layer->convertToLayerCoords(rootLayer, delta);
         clipRect.move(-delta.x(), -delta.y());
-        clipRect.unite(l->renderBox()->reflectedRect(clipRect));
+        clipRect.unite(layer->renderBox()->reflectedRect(clipRect));
         clipRect.moveBy(delta);
     }
 }
 
-static IntRect transparencyClipBox(const RenderLayer* l, const RenderLayer* rootLayer, PaintBehavior paintBehavior)
+static LayoutRect transparencyClipBox(const RenderLayer* layer, const RenderLayer* rootLayer, PaintBehavior paintBehavior)
 {
     // FIXME: Although this function completely ignores CSS-imposed clipping, we did already intersect with the
@@ -921 +921 @@
     // would be better to respect clips.
     
-    if (rootLayer != l && l->paintsWithTransform(paintBehavior)) {
+    if (rootLayer != layer && layer->paintsWithTransform(paintBehavior)) {
         // The best we can do here is to use enclosed bounding boxes to establish a "fuzzy" enough clip to encompass
         // the transformed layer and all of its children.
-        IntPoint delta;
-        l->convertToLayerCoords(rootLayer, delta);
+        LayoutPoint delta;
+        layer->convertToLayerCoords(rootLayer, delta);
 
         TransformationMatrix transform;
         transform.translate(delta.x(), delta.y());
-        transform = transform * *l->transform();
-
-        IntRect clipRect = l->boundingBox(l);
-        expandClipRectForDescendantsAndReflection(clipRect, l, l, paintBehavior);
+        transform = transform * *layer->transform();
+
+        LayoutRect clipRect = layer->boundingBox(layer);
+        expandClipRectForDescendantsAndReflection(clipRect, layer, layer, paintBehavior);
         return transform.mapRect(clipRect);
     }
     
-    IntRect clipRect = l->boundingBox(rootLayer);
-    expandClipRectForDescendantsAndReflection(clipRect, l, rootLayer, paintBehavior);
+    LayoutRect clipRect = layer->boundingBox(rootLayer);
+    expandClipRectForDescendantsAndReflection(clipRect, layer, rootLayer, paintBehavior);
     return clipRect;
 }
@@ -953 +953 @@
         m_usedTransparency = true;
         p->save();
-        IntRect clipRect = transparencyClipBox(this, rootLayer, paintBehavior);
+        LayoutRect clipRect = transparencyClipBox(this, rootLayer, paintBehavior);
         p->clip(clipRect);
         p->beginTransparencyLayer(renderer()->opacity());
@@ -1116 +1116 @@
 
 void 
-RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, IntPoint& location) const
+RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutPoint& location) const
 {
     if (ancestorLayer == this)
@@ -1126 +1126 @@
         // localToAbsolute() on the RenderView.
         FloatPoint absPos = renderer()->localToAbsolute(FloatPoint(), true);
-        location += flooredIntSize(absPos);
+        location += flooredLayoutSize(absPos);
         return;
     }
@@ -1150 +1150 @@
 
         if (fixedPositionContainerLayer != ancestorLayer) {
-            IntPoint fixedContainerCoords;
+            LayoutPoint fixedContainerCoords;
             convertToLayerCoords(fixedPositionContainerLayer, fixedContainerCoords);
 
-            IntPoint ancestorCoords;
+            LayoutPoint ancestorCoords;
             ancestorLayer->convertToLayerCoords(fixedPositionContainerLayer, ancestorCoords);
 
@@ -1183 +1183 @@
             RenderLayer* positionedAncestor = parentLayer->enclosingPositionedAncestor();
 
-            IntPoint thisCoords;
+            LayoutPoint thisCoords;
             convertToLayerCoords(positionedAncestor, thisCoords);
             
-            IntPoint ancestorCoords;
+            LayoutPoint ancestorCoords;
             ancestorLayer->convertToLayerCoords(positionedAncestor, ancestorCoords);
 
@@ -1204 +1204 @@
 
 void
-RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, IntRect& rect) const
-{
-    IntPoint delta;
+RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect& rect) const
+{
+    LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     rect.move(-delta.x(), -delta.y());
@@ -1225 +1225 @@
 }
 
-void RenderLayer::panScrollFromPoint(const IntPoint& sourcePoint) 
+void RenderLayer::panScrollFromPoint(const LayoutPoint& sourcePoint) 
 {
     Frame* frame = renderer()->frame();
@@ -1231 +1231 @@
         return;
     
-    IntPoint currentMousePosition = frame->eventHandler()->currentMousePosition();
+    LayoutPoint currentMousePosition = frame->eventHandler()->currentMousePosition();
     
     // We need to check if the current mouse position is out of the window. When the mouse is out of the window, the position is incoherent
-    static IntPoint previousMousePosition;
+    static LayoutPoint previousMousePosition;
     if (currentMousePosition.x() < 0 || currentMousePosition.y() < 0)
         currentMousePosition = previousMousePosition;
@@ -1240 +1240 @@
         previousMousePosition = currentMousePosition;
 
-    int xDelta = currentMousePosition.x() - sourcePoint.x();
-    int yDelta = currentMousePosition.y() - sourcePoint.y();
+    LayoutUnit xDelta = currentMousePosition.x() - sourcePoint.x();
+    LayoutUnit yDelta = currentMousePosition.y() - sourcePoint.y();
 
     if (abs(xDelta) <= ScrollView::noPanScrollRadius) // at the center we let the space for the icon
@@ -1251 +1251 @@
 }
 
-void RenderLayer::scrollByRecursively(int xDelta, int yDelta)
+void RenderLayer::scrollByRecursively(LayoutUnit xDelta, LayoutUnit yDelta)
 {
     if (!xDelta && !yDelta)
@@ -1261 +1261 @@
 
     if (renderer()->hasOverflowClip() && !restrictedByLineClamp) {
-        int newOffsetX = scrollXOffset() + xDelta;
-        int newOffsetY = scrollYOffset() + yDelta;
+        LayoutUnit newOffsetX = scrollXOffset() + xDelta;
+        LayoutUnit newOffsetY = scrollYOffset() + yDelta;
         scrollToOffset(newOffsetX, newOffsetY);
 
         // 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();
+        LayoutUnit leftToScrollX = newOffsetX - scrollXOffset();
+        LayoutUnit leftToScrollY = newOffsetY - scrollYOffset();
         if ((leftToScrollX || leftToScrollY) && renderer()->parent()) {
             if (RenderLayer* scrollableLayer = enclosingScrollableLayer())
@@ -1279 +1279 @@
         // 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(LayoutSize(xDelta, yDelta));
         // 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
@@ -1285 +1285 @@
 }
 
-void RenderLayer::scrollToOffset(int x, int y, ScrollOffsetClamping clamp)
+void RenderLayer::scrollToOffset(LayoutUnit x, LayoutUnit y, ScrollOffsetClamping clamp)
 {
     if (clamp == ScrollOffsetClamped) {
@@ -1292 +1292 @@
             return;
 
-        int maxX = scrollWidth() - box->clientWidth();
-        int maxY = scrollHeight() - box->clientHeight();
-
-        x = min(max(x, 0), maxX);
-        y = min(max(y, 0), maxY);
-    }
-    
-    ScrollableArea::scrollToOffsetWithoutAnimation(IntPoint(x, y));
-}
-
-void RenderLayer::scrollTo(int x, int y)
+        LayoutUnit maxX = scrollWidth() - box->clientWidth();
+        LayoutUnit maxY = scrollHeight() - box->clientHeight();
+
+        x = min(max<LayoutUnit>(x, 0), maxX);
+        y = min(max<LayoutUnit>(y, 0), maxY);
+    }
+    
+    ScrollableArea::scrollToOffsetWithoutAnimation(LayoutPoint(x, y));
+}
+
+void RenderLayer::scrollTo(LayoutUnit x, LayoutUnit y)
 {
     RenderBox* box = renderBox();
@@ -1319 +1319 @@
     // is either occluded by another layer or clipped by an enclosing
     // layer or contains fixed backgrounds, etc.).
-    IntSize newScrollOffset = IntSize(x - m_scrollOrigin.x(), y - m_scrollOrigin.y());
+    LayoutSize newScrollOffset = LayoutSize(x - m_scrollOrigin.x(), y - m_scrollOrigin.y());
     if (m_scrollOffset == newScrollOffset)
         return;
@@ -1359 +1359 @@
 
     RenderBoxModelObject* repaintContainer = renderer()->containerForRepaint();
-    IntRect rectForRepaint = renderer()->clippedOverflowRectForRepaint(repaintContainer);
+    LayoutRect rectForRepaint = renderer()->clippedOverflowRectForRepaint(repaintContainer);
 
     Frame* frame = renderer()->frame();
@@ -1381 +1381 @@
 }
 
-void RenderLayer::scrollRectToVisible(const IntRect& rect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
+void RenderLayer::scrollRectToVisible(const LayoutRect& rect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
 {
     RenderLayer* parentLayer = 0;
-    IntRect newRect = rect;
+    LayoutRect newRect = rect;
 
     // We may end up propagating a scroll event. It is important that we suspend events until 
@@ -1406 +1406 @@
         absPos.move(box->borderLeft(), box->borderTop());
 
-        IntRect layerBounds = IntRect(absPos.x() + scrollXOffset(), absPos.y() + scrollYOffset(), box->clientWidth(), box->clientHeight());
-        IntRect exposeRect = IntRect(rect.x() + scrollXOffset(), rect.y() + scrollYOffset(), rect.width(), rect.height());
-        IntRect r = getRectToExpose(layerBounds, exposeRect, alignX, alignY);
+        LayoutRect layerBounds = LayoutRect(absPos.x() + scrollXOffset(), absPos.y() + scrollYOffset(), box->clientWidth(), box->clientHeight());
+        LayoutRect exposeRect = LayoutRect(rect.x() + scrollXOffset(), rect.y() + scrollYOffset(), rect.width(), rect.height());
+        LayoutRect r = getRectToExpose(layerBounds, exposeRect, alignX, alignY);
         
-        int xOffset = r.x() - absPos.x();
-        int yOffset = r.y() - absPos.y();
+        LayoutUnit xOffset = r.x() - absPos.x();
+        LayoutUnit yOffset = r.y() - absPos.y();
         // Adjust offsets if they're outside of the allowable range.
-        xOffset = max(0, min(scrollWidth() - layerBounds.width(), xOffset));
-        yOffset = max(0, min(scrollHeight() - layerBounds.height(), yOffset));
+        xOffset = max<LayoutUnit>(0, min(scrollWidth() - layerBounds.width(), xOffset));
+        yOffset = max<LayoutUnit>(0, min(scrollHeight() - layerBounds.height(), yOffset));
         
         if (xOffset != scrollXOffset() || yOffset != scrollYOffset()) {
-            int diffX = scrollXOffset();
-            int diffY = scrollYOffset();
+            LayoutUnit diffX = scrollXOffset();
+            LayoutUnit diffY = scrollYOffset();
             scrollToOffset(xOffset, yOffset);
             diffX = scrollXOffset() - diffX;
@@ -1428 +1428 @@
         if (frameView) {
             if (renderer()->document() && renderer()->document()->ownerElement() && renderer()->document()->ownerElement()->renderer()) {
-                IntRect viewRect = frameView->visibleContentRect();
-                IntRect r = getRectToExpose(viewRect, rect, alignX, alignY);
+                LayoutRect viewRect = frameView->visibleContentRect();
+                LayoutRect r = getRectToExpose(viewRect, rect, alignX, alignY);
                 
-                int xOffset = r.x();
-                int yOffset = r.y();
+                LayoutUnit xOffset = r.x();
+                LayoutUnit yOffset = r.y();
                 // Adjust offsets if they're outside of the allowable range.
-                xOffset = max(0, min(frameView->contentsWidth(), xOffset));
-                yOffset = max(0, min(frameView->contentsHeight(), yOffset));
-
-                frameView->setScrollPosition(IntPoint(xOffset, yOffset));
+                xOffset = max<LayoutUnit>(0, min(frameView->contentsWidth(), xOffset));
+                yOffset = max<LayoutUnit>(0, min(frameView->contentsHeight(), yOffset));
+
+                frameView->setScrollPosition(LayoutPoint(xOffset, yOffset));
                 parentLayer = renderer()->document()->ownerElement()->renderer()->enclosingLayer();
                 newRect.setX(rect.x() - frameView->scrollX() + frameView->x());
                 newRect.setY(rect.y() - frameView->scrollY() + frameView->y());
             } else {
-                IntRect viewRect = frameView->visibleContentRect();
-                IntRect r = getRectToExpose(viewRect, rect, alignX, alignY);
+                LayoutRect viewRect = frameView->visibleContentRect();
+                LayoutRect r = getRectToExpose(viewRect, rect, alignX, alignY);
                 
                 frameView->setScrollPosition(r.location());
@@ -1467 +1467 @@
 }
 
-IntRect RenderLayer::getRectToExpose(const IntRect &visibleRect, const IntRect &exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
+LayoutRect RenderLayer::getRectToExpose(const LayoutRect &visibleRect, const LayoutRect &exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
 {
     // Determine the appropriate X behavior.
     ScrollBehavior scrollX;
-    IntRect exposeRectX(exposeRect.x(), visibleRect.y(), exposeRect.width(), visibleRect.height());
-    int intersectWidth = intersection(visibleRect, exposeRectX).width();
+    LayoutRect exposeRectX(exposeRect.x(), visibleRect.y(), exposeRect.width(), visibleRect.height());
+    LayoutUnit intersectWidth = intersection(visibleRect, exposeRectX).width();
     if (intersectWidth == exposeRect.width() || intersectWidth >= MIN_INTERSECT_FOR_REVEAL)
         // If the rectangle is fully visible, use the specified visible behavior.
@@ -1494 +1494 @@
 
     // Given the X behavior, compute the X coordinate.
-    int x;
+    LayoutUnit x;
     if (scrollX == noScroll) 
         x = visibleRect.x();
@@ -1506 +1506 @@
     // Determine the appropriate Y behavior.
     ScrollBehavior scrollY;
-    IntRect exposeRectY(visibleRect.x(), exposeRect.y(), visibleRect.width(), exposeRect.height());
-    int intersectHeight = intersection(visibleRect, exposeRectY).height();
+    LayoutRect exposeRectY(visibleRect.x(), exposeRect.y(), visibleRect.width(), exposeRect.height());
+    LayoutUnit intersectHeight = intersection(visibleRect, exposeRectY).height();
     if (intersectHeight == exposeRect.height())
         // If the rectangle is fully visible, use the specified visible behavior.
@@ -1527 +1527 @@
 
     // Given the Y behavior, compute the Y coordinate.
-    int y;
+    LayoutUnit y;
     if (scrollY == noScroll) 
         y = visibleRect.y();
@@ -1537 +1537 @@
         y = exposeRect.y();
 
-    return IntRect(IntPoint(x, y), visibleRect.size());
+    return LayoutRect(LayoutPoint(x, y), visibleRect.size());
 }
 
@@ -1554 +1554 @@
 #endif
 
-    IntPoint currentDocumentPosition = frameView->windowToContents(frame->eventHandler()->currentMousePosition());
-    scrollRectToVisible(IntRect(currentDocumentPosition, IntSize(1, 1)), ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
+    LayoutPoint currentDocumentPosition = frameView->windowToContents(frame->eventHandler()->currentMousePosition());
+    scrollRectToVisible(LayoutRect(currentDocumentPosition, LayoutSize(1, 1)), ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
 }
 
@@ -1623 +1623 @@
 }
 
-int RenderLayer::scrollSize(ScrollbarOrientation orientation) const
+LayoutUnit RenderLayer::scrollSize(ScrollbarOrientation orientation) const
 {
     Scrollbar* scrollbar = ((orientation == HorizontalScrollbar) ? m_hBar : m_vBar).get();
@@ -1629 +1629 @@
 }
 
-void RenderLayer::setScrollOffset(const IntPoint& offset)
+void RenderLayer::setScrollOffset(const LayoutPoint& offset)
 {
     scrollTo(offset.x(), offset.y());
 }
 
-int RenderLayer::scrollPosition(Scrollbar* scrollbar) const
+LayoutUnit RenderLayer::scrollPosition(Scrollbar* scrollbar) const
 {
     if (scrollbar->orientation() == HorizontalScrollbar)
@@ -1643 +1643 @@
 }
 
-IntPoint RenderLayer::scrollPosition() const
+LayoutPoint RenderLayer::scrollPosition() const
 {
     return m_scrollOrigin + m_scrollOffset;
 }
 
-IntPoint RenderLayer::minimumScrollPosition() const
+LayoutPoint RenderLayer::minimumScrollPosition() const
 {
     return m_scrollOrigin;
 }
 
-IntPoint RenderLayer::maximumScrollPosition() const
+LayoutPoint RenderLayer::maximumScrollPosition() const
 {
     // FIXME: m_scrollSize may not be up-to-date if m_scrollDimensionsDirty is true.
@@ -1659 +1659 @@
 }
 
-IntRect RenderLayer::visibleContentRect(bool includeScrollbars) const
-{
-    int verticalScrollbarWidth = 0;
-    int horizontalScrollbarHeight = 0;
+LayoutRect RenderLayer::visibleContentRect(bool includeScrollbars) const
+{
+    LayoutUnit verticalScrollbarWidth = 0;
+    LayoutUnit horizontalScrollbarHeight = 0;
     if (includeScrollbars) {
         verticalScrollbarWidth = (verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar()) ? verticalScrollbar()->width() : 0;
@@ -1668 +1668 @@
     }
     
-    return IntRect(IntPoint(scrollXOffset(), scrollYOffset()),
-                   IntSize(max(0, m_layerSize.width() - verticalScrollbarWidth), 
-                           max(0, m_layerSize.height() - horizontalScrollbarHeight)));
-}
-
-IntSize RenderLayer::overhangAmount() const
-{
-    return IntSize();
-}
-
-void RenderLayer::didCompleteRubberBand(const IntSize&) const
+    return LayoutRect(LayoutPoint(scrollXOffset(), scrollYOffset()),
+                      LayoutSize(max<LayoutUnit>(0, m_layerSize.width() - verticalScrollbarWidth), 
+                                 max<LayoutUnit>(0, m_layerSize.height() - horizontalScrollbarHeight)));
+}
+
+LayoutSize RenderLayer::overhangAmount() const
+{
+    return LayoutSize();
+}
+
+void RenderLayer::didCompleteRubberBand(const LayoutSize&) const
 {
 }
@@ -1688 +1688 @@
 }
 
-static IntRect cornerRect(const RenderLayer* layer, const IntRect& bounds)
+static LayoutRect cornerRect(const RenderLayer* layer, const LayoutRect& bounds)
 {
     int horizontalThickness;
@@ -1707 +1707 @@
         verticalThickness = layer->horizontalScrollbar()->height();
     }
-    return IntRect(bounds.maxX() - horizontalThickness - layer->renderer()->style()->borderRightWidth(), 
-                   bounds.maxY() - verticalThickness - layer->renderer()->style()->borderBottomWidth(),
-                   horizontalThickness, verticalThickness);
-}
-
-IntRect RenderLayer::scrollCornerRect() const
+    return LayoutRect(bounds.maxX() - horizontalThickness - layer->renderer()->style()->borderRightWidth(), 
+                      bounds.maxY() - verticalThickness - layer->renderer()->style()->borderBottomWidth(),
+                      horizontalThickness, verticalThickness);
+}
+
+LayoutRect RenderLayer::scrollCornerRect() const
 {
     // We have a scrollbar corner when a scrollbar is visible and not filling the entire length of the box.
@@ -1723 +1723 @@
     if ((hasHorizontalBar && hasVerticalBar) || (hasResizer && (hasHorizontalBar || hasVerticalBar)))
         return cornerRect(this, renderBox()->borderBoxRect());
-    return IntRect();
-}
-
-static IntRect resizerCornerRect(const RenderLayer* layer, const IntRect& bounds)
+    return LayoutRect();
+}
+
+static LayoutRect resizerCornerRect(const RenderLayer* layer, const LayoutRect& bounds)
 {
     ASSERT(layer->renderer()->isBox());
     if (layer->renderer()->style()->resize() == RESIZE_NONE)
-        return IntRect();
+        return LayoutRect();
     return cornerRect(layer, bounds);
 }
 
-IntRect RenderLayer::scrollCornerAndResizerRect() const
+LayoutRect RenderLayer::scrollCornerAndResizerRect() const
 {
     RenderBox* box = renderBox();
     if (!box)
-        return IntRect();
-    IntRect scrollCornerAndResizer = scrollCornerRect();
+        return LayoutRect();
+    LayoutRect scrollCornerAndResizer = scrollCornerRect();
     if (scrollCornerAndResizer.isEmpty())
         scrollCornerAndResizer = resizerCornerRect(this, box->borderBoxRect());
@@ -1751 +1751 @@
 }
 
-IntRect RenderLayer::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& scrollbarRect) const
+LayoutRect RenderLayer::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const LayoutRect& scrollbarRect) const
 {
     RenderView* view = renderer()->view();
@@ -1757 +1757 @@
         return scrollbarRect;
 
-    IntRect rect = scrollbarRect;
+    LayoutRect rect = scrollbarRect;
     rect.move(scrollbarOffset(scrollbar));
 
@@ -1763 +1763 @@
 }
 
-IntRect RenderLayer::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
+LayoutRect RenderLayer::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const LayoutRect& parentRect) const
 {
     RenderView* view = renderer()->view();
@@ -1769 +1769 @@
         return parentRect;
 
-    IntRect rect = view->frameView()->convertToRenderer(renderer(), parentRect);
+    LayoutRect rect = view->frameView()->convertToRenderer(renderer(), parentRect);
     rect.move(-scrollbarOffset(scrollbar));
     return rect;
 }
 
-IntPoint RenderLayer::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& scrollbarPoint) const
+LayoutPoint RenderLayer::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const LayoutPoint& scrollbarPoint) const
 {
     RenderView* view = renderer()->view();
@@ -1780 +1780 @@
         return scrollbarPoint;
 
-    IntPoint point = scrollbarPoint;
+    LayoutPoint point = scrollbarPoint;
     point.move(scrollbarOffset(scrollbar));
     return view->frameView()->convertFromRenderer(renderer(), point);
 }
 
-IntPoint RenderLayer::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
+LayoutPoint RenderLayer::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const LayoutPoint& parentPoint) const
 {
     RenderView* view = renderer()->view();
@@ -1791 +1791 @@
         return parentPoint;
 
-    IntPoint point = view->frameView()->convertToRenderer(renderer(), parentPoint);
+    LayoutPoint point = view->frameView()->convertToRenderer(renderer(), parentPoint);
 
     point.move(-scrollbarOffset(scrollbar));
@@ -1797 +1797 @@
 }
 
-IntSize RenderLayer::contentsSize() const
-{
-    return IntSize(const_cast<RenderLayer*>(this)->scrollWidth(), const_cast<RenderLayer*>(this)->scrollHeight());
+LayoutSize RenderLayer::contentsSize() const
+{
+    return LayoutSize(const_cast<RenderLayer*>(this)->scrollWidth(), const_cast<RenderLayer*>(this)->scrollHeight());
 }
 
@@ -1825 +1825 @@
 }
 
-IntPoint RenderLayer::currentMousePosition() const
-{
-    return renderer()->frame() ? renderer()->frame()->eventHandler()->currentMousePosition() : IntPoint();
-}
-
-IntSize RenderLayer::scrollbarOffset(const Scrollbar* scrollbar) const
+LayoutPoint RenderLayer::currentMousePosition() const
+{
+    return renderer()->frame() ? renderer()->frame()->eventHandler()->currentMousePosition() : LayoutPoint();
+}
+
+LayoutSize RenderLayer::scrollbarOffset(const Scrollbar* scrollbar) const
 {
     RenderBox* box = renderBox();
 
     if (scrollbar == m_vBar.get())
-        return IntSize(box->width() - box->borderRight() - scrollbar->width(), box->borderTop());
+        return LayoutSize(box->width() - box->borderRight() - scrollbar->width(), box->borderTop());
 
     if (scrollbar == m_hBar.get())
-        return IntSize(box->borderLeft(), box->height() - box->borderBottom() - scrollbar->height());
+        return LayoutSize(box->borderLeft(), box->height() - box->borderBottom() - scrollbar->height());
     
     ASSERT_NOT_REACHED();
-    return IntSize();
-}
-
-void RenderLayer::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
+    return LayoutSize();
+}
+
+void RenderLayer::invalidateScrollbarRect(Scrollbar* scrollbar, const LayoutRect& rect)
 {
 #if USE(ACCELERATED_COMPOSITING)
@@ -1859 +1859 @@
     }
 #endif
-    IntRect scrollRect = rect;
+    LayoutRect scrollRect = rect;
     RenderBox* box = renderBox();
     ASSERT(box);
@@ -1869 +1869 @@
 }
 
-void RenderLayer::invalidateScrollCornerRect(const IntRect& rect)
+void RenderLayer::invalidateScrollCornerRect(const LayoutRect& rect)
 {
 #if USE(ACCELERATED_COMPOSITING)
@@ -2030 +2030 @@
 }
 
-void RenderLayer::positionOverflowControls(const IntSize& offsetFromLayer)
+void RenderLayer::positionOverflowControls(const LayoutSize& offsetFromLayer)
 {
     if (!m_hBar && !m_vBar && (!renderer()->hasOverflowClip() || renderer()->style()->resize() == RESIZE_NONE))
@@ -2039 +2039 @@
         return;
 
-    const IntRect& borderBox = box->borderBoxRect();
-    const IntRect& scrollCorner = scrollCornerRect();
-    IntRect absBounds(borderBox.location() + offsetFromLayer, borderBox.size());
+    const LayoutRect& borderBox = box->borderBoxRect();
+    const LayoutRect& scrollCorner = scrollCornerRect();
+    LayoutRect absBounds(borderBox.location() + offsetFromLayer, borderBox.size());
     if (m_vBar)
-        m_vBar->setFrameRect(IntRect(absBounds.maxX() - box->borderRight() - m_vBar->width(),
-                                     absBounds.y() + box->borderTop(),
-                                     m_vBar->width(),
-                                     absBounds.height() - (box->borderTop() + box->borderBottom()) - scrollCorner.height()));
+        m_vBar->setFrameRect(LayoutRect(absBounds.maxX() - box->borderRight() - m_vBar->width(),
+                                        absBounds.y() + box->borderTop(),
+                                        m_vBar->width(),
+                                        absBounds.height() - (box->borderTop() + box->borderBottom()) - scrollCorner.height()));
 
     if (m_hBar)
-        m_hBar->setFrameRect(IntRect(absBounds.x() + box->borderLeft(),
-                                     absBounds.maxY() - box->borderBottom() - m_hBar->height(),
-                                     absBounds.width() - (box->borderLeft() + box->borderRight()) - scrollCorner.width(),
-                                     m_hBar->height()));
+        m_hBar->setFrameRect(LayoutRect(absBounds.x() + box->borderLeft(),
+                                        absBounds.maxY() - box->borderBottom() - m_hBar->height(),
+                                        absBounds.width() - (box->borderLeft() + box->borderRight()) - scrollCorner.width(),
+                                        m_hBar->height()));
 
 #if USE(ACCELERATED_COMPOSITING)
@@ -2071 +2071 @@
 
     if (GraphicsLayer* layer = layerForScrollCorner()) {
-        const IntRect& scrollCornerAndResizer = scrollCornerAndResizerRect();
+        const LayoutRect& scrollCornerAndResizer = scrollCornerAndResizerRect();
         layer->setPosition(scrollCornerAndResizer.location());
         layer->setSize(scrollCornerAndResizer.size());
@@ -2084 +2084 @@
 }
 
-int RenderLayer::scrollWidth()
+LayoutUnit RenderLayer::scrollWidth()
 {
     if (m_scrollDimensionsDirty)
@@ -2091 +2091 @@
 }
 
-int RenderLayer::scrollHeight()
+LayoutUnit RenderLayer::scrollHeight()
 {
     if (m_scrollDimensionsDirty)
@@ -2098 +2098 @@
 }
 
-int RenderLayer::overflowTop() const
+LayoutUnit RenderLayer::overflowTop() const
 {
     RenderBox* box = renderBox();
-    IntRect overflowRect(box->layoutOverflowRect());
+    LayoutRect overflowRect(box->layoutOverflowRect());
     box->flipForWritingMode(overflowRect);
     return overflowRect.y();
 }
 
-int RenderLayer::overflowBottom() const
+LayoutUnit RenderLayer::overflowBottom() const
 {
     RenderBox* box = renderBox();
-    IntRect overflowRect(box->layoutOverflowRect());
+    LayoutRect overflowRect(box->layoutOverflowRect());
     box->flipForWritingMode(overflowRect);
     return overflowRect.maxY();
 }
 
-int RenderLayer::overflowLeft() const
+LayoutUnit RenderLayer::overflowLeft() const
 {
     RenderBox* box = renderBox();
-    IntRect overflowRect(box->layoutOverflowRect());
+    LayoutRect overflowRect(box->layoutOverflowRect());
     box->flipForWritingMode(overflowRect);
     return overflowRect.x();
 }
 
-int RenderLayer::overflowRight() const
+LayoutUnit RenderLayer::overflowRight() const
 {
     RenderBox* box = renderBox();
-    IntRect overflowRect(box->layoutOverflowRect());
+    LayoutRect overflowRect(box->layoutOverflowRect());
     box->flipForWritingMode(overflowRect);
     return overflowRect.maxX();
@@ -2143 +2143 @@
     m_scrollSize.setHeight(overflowBottom() - overflowTop());
     
-    m_scrollOrigin = IntPoint(-m_scrollOverflow.width(), -m_scrollOverflow.height());
+    m_scrollOrigin = LayoutPoint(-m_scrollOverflow.width(), -m_scrollOverflow.height());
 
     if (needHBar)
@@ -2188 +2188 @@
         // Layout may cause us to be in 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(scrollXOffset(), scrollWidth() - box->clientWidth()));
-        int newY = max(0, min(scrollYOffset(), scrollHeight() - box->clientHeight()));
+        LayoutUnit newX = max<LayoutUnit>(0, min(scrollXOffset(), scrollWidth() - box->clientWidth()));
+        LayoutUnit newY = max<LayoutUnit>(0, min(scrollYOffset(), scrollHeight() - box->clientHeight()));
         if (newX != scrollXOffset() || newY != scrollYOffset()) {
             RenderView* view = renderer()->view();
@@ -2259 +2259 @@
     // Set up the range (and page step/line step).
     if (m_hBar) {
-        int clientWidth = box->clientWidth();
-        int pageStep = max(max<int>(clientWidth * Scrollbar::minFractionToStepWhenPaging(), clientWidth - Scrollbar::maxOverlapBetweenPages()), 1);
+        LayoutUnit clientWidth = box->clientWidth();
+        LayoutUnit pageStep = max<LayoutUnit>(max<LayoutUnit>(clientWidth * Scrollbar::minFractionToStepWhenPaging(), clientWidth - Scrollbar::maxOverlapBetweenPages()), 1);
         m_hBar->setSteps(Scrollbar::pixelsPerLineStep(), pageStep);
         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);
+        LayoutUnit clientHeight = box->clientHeight();
+        LayoutUnit pageStep = max<LayoutUnit>(max<LayoutUnit>(clientHeight * Scrollbar::minFractionToStepWhenPaging(), clientHeight - Scrollbar::maxOverlapBetweenPages()), 1);
         m_vBar->setSteps(Scrollbar::pixelsPerLineStep(), pageStep);
         m_vBar->setProportion(clientHeight, m_scrollSize.height());
@@ -2281 +2281 @@
 }
 
-void RenderLayer::paintOverflowControls(GraphicsContext* context, const LayoutPoint& paintOffset, const IntRect& damageRect, bool paintingOverlayControls)
+void RenderLayer::paintOverflowControls(GraphicsContext* context, const LayoutPoint& paintOffset, const LayoutRect& damageRect, bool paintingOverlayControls)
 {
     // Don't do anything if we have no overflow.
@@ -2409 +2409 @@
 }
 
-bool RenderLayer::isPointInResizeControl(const IntPoint& absolutePoint) const
+bool RenderLayer::isPointInResizeControl(const LayoutPoint& absolutePoint) const
 {
     if (!renderer()->hasOverflowClip() || renderer()->style()->resize() == RESIZE_NONE)
@@ -2417 +2417 @@
     ASSERT(box);
 
-    IntPoint localPoint = absoluteToContents(absolutePoint);
-
-    IntRect localBounds(0, 0, box->width(), box->height());
+    LayoutPoint localPoint = absoluteToContents(absolutePoint);
+
+    LayoutRect localBounds(0, 0, box->width(), box->height());
     return resizerCornerRect(this, localBounds).contains(localPoint);
 }
     
-bool RenderLayer::hitTestOverflowControls(HitTestResult& result, const IntPoint& localPoint)
+bool RenderLayer::hitTestOverflowControls(HitTestResult& result, const LayoutPoint& localPoint)
 {
     if (!m_hBar && !m_vBar && (!renderer()->hasOverflowClip() || renderer()->style()->resize() == RESIZE_NONE))
@@ -2431 +2431 @@
     ASSERT(box);
     
-    IntRect resizeControlRect;
+    LayoutRect resizeControlRect;
     if (renderer()->style()->resize() != RESIZE_NONE) {
         resizeControlRect = resizerCornerRect(this, box->borderBoxRect());
@@ -2438 +2438 @@
     }
 
-    int resizeControlSize = max(resizeControlRect.height(), 0);
+    LayoutUnit resizeControlSize = max<LayoutUnit>(resizeControlRect.height(), 0);
 
     if (m_vBar) {
-        IntRect vBarRect(box->width() - box->borderRight() - m_vBar->width(), 
-                         box->borderTop(),
-                         m_vBar->width(),
-                         box->height() - (box->borderTop() + box->borderBottom()) - (m_hBar ? m_hBar->height() : resizeControlSize));
+        LayoutRect vBarRect(box->width() - box->borderRight() - m_vBar->width(), 
+                            box->borderTop(),
+                            m_vBar->width(),
+                            box->height() - (box->borderTop() + box->borderBottom()) - (m_hBar ? m_hBar->height() : resizeControlSize));
         if (vBarRect.contains(localPoint)) {
             result.setScrollbar(m_vBar.get());
@@ -2451 +2451 @@
     }
 
-    resizeControlSize = max(resizeControlRect.width(), 0);
+    resizeControlSize = max<LayoutUnit>(resizeControlRect.width(), 0);
     if (m_hBar) {
-        IntRect hBarRect(box->borderLeft(),
-                         box->height() - box->borderBottom() - m_hBar->height(),
-                         box->width() - (box->borderLeft() + box->borderRight()) - (m_vBar ? m_vBar->width() : resizeControlSize),
-                         m_hBar->height());
+        LayoutRect hBarRect(box->borderLeft(),
+                            box->height() - box->borderBottom() - m_hBar->height(),
+                            box->width() - (box->borderLeft() + box->borderRight()) - (m_vBar ? m_vBar->width() : resizeControlSize),
+                            m_hBar->height());
         if (hBarRect.contains(localPoint)) {
             result.setScrollbar(m_hBar.get());
@@ -2471 +2471 @@
 }
 
-void RenderLayer::paint(GraphicsContext* p, const IntRect& damageRect, PaintBehavior paintBehavior, RenderObject *paintingRoot)
+void RenderLayer::paint(GraphicsContext* p, const LayoutRect& damageRect, PaintBehavior paintBehavior, RenderObject *paintingRoot)
 {
     OverlapTestRequestMap overlapTestRequests;
@@ -2480 +2480 @@
 }
 
-void RenderLayer::paintOverlayScrollbars(GraphicsContext* p, const IntRect& damageRect, PaintBehavior paintBehavior, RenderObject *paintingRoot)
+void RenderLayer::paintOverlayScrollbars(GraphicsContext* p, const LayoutRect& damageRect, PaintBehavior paintBehavior, RenderObject *paintingRoot)
 {
     if (!m_containsDirtyOverlayScrollbars)
@@ -2489 +2489 @@
 }
 
-static void setClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect)
+static void setClip(GraphicsContext* p, const LayoutRect& paintDirtyRect, const LayoutRect& clipRect)
 {
     if (paintDirtyRect == clipRect)
@@ -2497 +2497 @@
 }
 
-static void restoreClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect)
+static void restoreClip(GraphicsContext* p, const LayoutRect& paintDirtyRect, const LayoutRect& clipRect)
 {
     if (paintDirtyRect == clipRect)
@@ -2508 +2508 @@
     Vector<OverlapTestRequestClient*> overlappedRequestClients;
     OverlapTestRequestMap::iterator end = overlapTestRequests.end();
-    IntRect boundingBox = layer->boundingBox(rootLayer);
+    LayoutRect boundingBox = layer->boundingBox(rootLayer);
     for (OverlapTestRequestMap::iterator it = overlapTestRequests.begin(); it != end; ++it) {
         if (!boundingBox.intersects(it->second))
@@ -2528 +2528 @@
 
 void RenderLayer::paintLayer(RenderLayer* rootLayer, GraphicsContext* p,
-                        const IntRect& paintDirtyRect, PaintBehavior paintBehavior,
+                        const LayoutRect& paintDirtyRect, PaintBehavior paintBehavior,
                         RenderObject* paintingRoot, OverlapTestRequestMap* overlapTestRequests,
                         PaintLayerFlags paintFlags)
@@ -2575 +2575 @@
 
         // Make sure the parent's clip rects have been calculated.
-        IntRect clipRect = paintDirtyRect;
+        LayoutRect clipRect = paintDirtyRect;
         if (parent()) {
             clipRect = backgroundClipRect(rootLayer, paintFlags & PaintLayerTemporaryClipRects);
@@ -2586 +2586 @@
         // Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.
         // This involves subtracting out the position of the layer in our current coordinate space.
-        IntPoint delta;
+        LayoutPoint delta;
         convertToLayerCoords(rootLayer, delta);
         TransformationMatrix transform(layerTransform);
@@ -2618 +2618 @@
 
     // Calculate the clip rects we should use.
-    IntRect layerBounds, damageRect, clipRectToApply, outlineRect;
+    LayoutRect layerBounds, damageRect, clipRectToApply, outlineRect;
     calculateRects(rootLayer, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect, localPaintFlags & PaintLayerTemporaryClipRects);
-    IntPoint paintOffset = toPoint(layerBounds.location() - renderBoxLocation());
+    LayoutPoint paintOffset = toPoint(layerBounds.location() - renderBoxLocation());
                              
     // Ensure our lists are up-to-date.
@@ -2729 +2729 @@
 
 void RenderLayer::paintList(Vector<RenderLayer*>* list, RenderLayer* rootLayer, GraphicsContext* p,
-                            const IntRect& paintDirtyRect, PaintBehavior paintBehavior,
+                            const LayoutRect& paintDirtyRect, PaintBehavior paintBehavior,
                             RenderObject* paintingRoot, OverlapTestRequestMap* overlapTestRequests,
                             PaintLayerFlags paintFlags)
@@ -2746 +2746 @@
 
 void RenderLayer::paintPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext* context,
-                                           const IntRect& paintDirtyRect, PaintBehavior paintBehavior,
+                                           const LayoutRect& paintDirtyRect, PaintBehavior paintBehavior,
                                            RenderObject* paintingRoot, OverlapTestRequestMap* overlapTestRequests,
                                            PaintLayerFlags paintFlags)
@@ -2766 +2766 @@
 
 void RenderLayer::paintChildLayerIntoColumns(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext* context,
-                                             const IntRect& paintDirtyRect, PaintBehavior paintBehavior,
+                                             const LayoutRect& paintDirtyRect, PaintBehavior paintBehavior,
                                              RenderObject* paintingRoot, OverlapTestRequestMap* overlapTestRequests,
                                              PaintLayerFlags paintFlags, const Vector<RenderLayer*>& columnLayers, size_t colIndex)
@@ -2776 +2776 @@
         return;
     
-    IntPoint layerOffset;
+    LayoutPoint layerOffset;
     columnBlock->layer()->convertToLayerCoords(rootLayer, layerOffset);
     
@@ -2786 +2786 @@
     for (unsigned i = 0; i < colCount; i++) {
         // For each rect, we clip to the rect, and then we adjust our coords.
-        IntRect colRect = columnBlock->columnRectAt(colInfo, i);
+        LayoutRect colRect = columnBlock->columnRectAt(colInfo, i);
         columnBlock->flipForWritingMode(colRect);
         int logicalLeftOffset = (isHorizontal ? colRect.x() : colRect.y()) - columnBlock->logicalLeftOffsetForContent();
-        IntSize offset = isHorizontal ? IntSize(logicalLeftOffset, currLogicalTopOffset) : IntSize(currLogicalTopOffset, logicalLeftOffset);
+        LayoutSize offset = isHorizontal ? LayoutSize(logicalLeftOffset, currLogicalTopOffset) : LayoutSize(currLogicalTopOffset, logicalLeftOffset);
 
         colRect.moveBy(layerOffset);
 
-        IntRect localDirtyRect(paintDirtyRect);
+        LayoutRect localDirtyRect(paintDirtyRect);
         localDirtyRect.intersect(colRect);
         
@@ -2821 +2821 @@
                 // Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.
                 // This involves subtracting out the position of the layer in our current coordinate space.
-                IntPoint childOffset;
+                LayoutPoint childOffset;
                 columnLayers[colIndex - 1]->convertToLayerCoords(rootLayer, childOffset);
                 TransformationMatrix transform;
@@ -2845 +2845 @@
 }
 
-static inline IntRect frameVisibleRect(RenderObject* renderer)
+static inline LayoutRect frameVisibleRect(RenderObject* renderer)
 {
     FrameView* frameView = renderer->document()->view();
     if (!frameView)
-        return IntRect();
+        return LayoutRect();
 
     return frameView->visibleContentRect();
@@ -2858 +2858 @@
     renderer()->document()->updateLayout();
     
-    IntRect hitTestArea = renderer()->view()->documentRect();
+    LayoutRect hitTestArea = renderer()->view()->documentRect();
     if (!request.ignoreClipping())
         hitTestArea.intersect(frameVisibleRect(renderer()));
@@ -2993 +2993 @@
         // Make sure the parent's clip rects have been calculated.
         if (parent()) {
-            IntRect clipRect = backgroundClipRect(rootLayer, useTemporaryClipRects, IncludeOverlayScrollbarSize);
+            LayoutRect clipRect = backgroundClipRect(rootLayer, useTemporaryClipRects, IncludeOverlayScrollbarSize);
             // Go ahead and test the enclosing clip now.
             if (!clipRect.intersects(hitTestArea))
@@ -3383 +3383 @@
     if (renderer()->hasOverflowClip() || renderer()->hasClip()) {
         // This layer establishes a clip of some kind.
-        IntPoint offset;
+        LayoutPoint offset;
         convertToLayerCoords(rootLayer, offset);
         RenderView* view = renderer()->view();
@@ -3392 +3392 @@
         
         if (renderer()->hasOverflowClip()) {
-            IntRect newOverflowClip = toRenderBox(renderer())->overflowClipRect(offset, relevancy);
+            LayoutRect newOverflowClip = toRenderBox(renderer())->overflowClipRect(offset, relevancy);
             clipRects.setOverflowClipRect(intersection(newOverflowClip, clipRects.overflowClipRect()));
             if (renderer()->isPositioned() || renderer()->isRelPositioned())
@@ -3398 +3398 @@
         }
         if (renderer()->hasClip()) {
-            IntRect newPosClip = toRenderBox(renderer())->clipRect(offset);
+            LayoutRect newPosClip = toRenderBox(renderer())->clipRect(offset);
             clipRects.setPosClipRect(intersection(newPosClip, clipRects.posClipRect()));
             clipRects.setOverflowClipRect(intersection(newPosClip, clipRects.overflowClipRect()));
@@ -3418 +3418 @@
 }
 
-IntRect RenderLayer::backgroundClipRect(const RenderLayer* rootLayer, bool temporaryClipRects, OverlayScrollbarSizeRelevancy relevancy) const
-{
-    IntRect backgroundRect;
+LayoutRect RenderLayer::backgroundClipRect(const RenderLayer* rootLayer, bool temporaryClipRects, OverlayScrollbarSizeRelevancy relevancy) const
+{
+    LayoutRect backgroundRect;
     if (parent()) {
         ClipRects parentRects;
@@ -3473 +3473 @@
             do {
                 if (boxShadow->style() == Normal) {
-                    IntRect shadowRect = layerBounds;
+                    LayoutRect shadowRect = layerBounds;
                     shadowRect.move(boxShadow->x(), boxShadow->y());
                     shadowRect.inflate(boxShadow->blur() + boxShadow->spread());
@@ -3487 +3487 @@
 }
 
-IntRect RenderLayer::childrenClipRect() const
+LayoutRect RenderLayer::childrenClipRect() const
 {
     RenderView* renderView = renderer()->view();
     RenderLayer* clippingRootLayer = clippingRoot();
-    IntRect layerBounds, backgroundRect, foregroundRect, outlineRect;
+    LayoutRect layerBounds, backgroundRect, foregroundRect, outlineRect;
     calculateRects(clippingRootLayer, renderView->unscaledDocumentRect(), layerBounds, backgroundRect, foregroundRect, outlineRect);
     return clippingRootLayer->renderer()->localToAbsoluteQuad(FloatQuad(foregroundRect)).enclosingBoundingBox();
 }
 
-IntRect RenderLayer::selfClipRect() const
+LayoutRect RenderLayer::selfClipRect() const
 {
     RenderView* renderView = renderer()->view();
     RenderLayer* clippingRootLayer = clippingRoot();
-    IntRect layerBounds, backgroundRect, foregroundRect, outlineRect;
+    LayoutRect layerBounds, backgroundRect, foregroundRect, outlineRect;
     calculateRects(clippingRootLayer, renderView->documentRect(), layerBounds, backgroundRect, foregroundRect, outlineRect);
     return clippingRootLayer->renderer()->localToAbsoluteQuad(FloatQuad(backgroundRect)).enclosingBoundingBox();
 }
 
-void RenderLayer::addBlockSelectionGapsBounds(const IntRect& bounds)
+void RenderLayer::addBlockSelectionGapsBounds(const LayoutRect& bounds)
 {
     m_blockSelectionGapsBounds.unite(bounds);
@@ -3512 +3512 @@
 void RenderLayer::clearBlockSelectionGapsBounds()
 {
-    m_blockSelectionGapsBounds = IntRect();
+    m_blockSelectionGapsBounds = LayoutRect();
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
         child->clearBlockSelectionGapsBounds();
@@ -3525 +3525 @@
         return;
 
-    IntRect rect = m_blockSelectionGapsBounds;
+    LayoutRect rect = m_blockSelectionGapsBounds;
     rect.move(-scrolledContentOffset());
     if (renderer()->hasOverflowClip())
-        rect.intersect(toRenderBox(renderer())->overflowClipRect(IntPoint()));
+        rect.intersect(toRenderBox(renderer())->overflowClipRect(LayoutPoint()));
     if (renderer()->hasClip())
-        rect.intersect(toRenderBox(renderer())->clipRect(IntPoint()));
+        rect.intersect(toRenderBox(renderer())->clipRect(LayoutPoint()));
     if (!rect.isEmpty())
         renderer()->repaintRectangle(rect);
 }
 
-bool RenderLayer::intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect, const RenderLayer* rootLayer) const
+bool RenderLayer::intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer) const
 {
     // Always examine the canvas and the root.
@@ -3548 +3548 @@
     ASSERT(view);
     if (view && !renderer()->isRenderInline()) {
-        IntRect b = layerBounds;
+        LayoutRect b = layerBounds;
         b.inflate(view->maximalOutlineSize());
         if (b.intersects(damageRect))
@@ -3559 +3559 @@
 }
 
-IntRect RenderLayer::localBoundingBox() const
+LayoutRect RenderLayer::localBoundingBox() const
 {
     // There are three special cases we need to consider.
@@ -3570 +3570 @@
     // as part of our bounding box.  We do this because we are the responsible layer for both hit testing and painting those
     // floats.
-    IntRect result;
+    LayoutRect result;
     if (renderer()->isRenderInline())
         result = toRenderInline(renderer())->linesVisualOverflowBoundingBox();
@@ -3577 +3577 @@
         for (RenderObject* child = renderer()->firstChild(); child; child = child->nextSibling()) {
             if (child->isTableCell()) {
-                IntRect bbox = toRenderBox(child)->borderBoxRect();
+                LayoutRect bbox = toRenderBox(child)->borderBoxRect();
                 result.unite(bbox);
-                IntRect overflowRect = renderBox()->visualOverflowRect();
+                LayoutRect overflowRect = renderBox()->visualOverflowRect();
                 if (bbox != overflowRect)
                     result.unite(overflowRect);
@@ -3590 +3590 @@
             result = box->maskClipRect();
         else {
-            IntRect bbox = box->borderBoxRect();
+            LayoutRect bbox = box->borderBoxRect();
             result = bbox;
-            IntRect overflowRect = box->visualOverflowRect();
+            LayoutRect overflowRect = box->visualOverflowRect();
             if (bbox != overflowRect)
                 result.unite(overflowRect);
@@ -3606 +3606 @@
 }
 
-IntRect RenderLayer::boundingBox(const RenderLayer* ancestorLayer) const
+LayoutRect RenderLayer::boundingBox(const RenderLayer* ancestorLayer) const
 {    
-    IntRect result = localBoundingBox();
+    LayoutRect result = localBoundingBox();
     if (renderer()->isBox())
         renderBox()->flipForWritingMode(result);
     else
         renderer()->containingBlock()->flipForWritingMode(result);
-    IntPoint delta;
+    LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     result.moveBy(delta);
@@ -3619 +3619 @@
 }
 
-IntRect RenderLayer::absoluteBoundingBox() const
+LayoutRect RenderLayer::absoluteBoundingBox() const
 {
     return boundingBox(root());
@@ -3943 +3943 @@
 }
 
-void RenderLayer::setBackingNeedsRepaintInRect(const IntRect& r)
+void RenderLayer::setBackingNeedsRepaintInRect(const LayoutRect& r)
 {
     // https://bugs.webkit.org/show_bug.cgi?id=61159 describes an unreproducible crash here,
@@ -3951 +3951 @@
         // If we're trying to repaint the placeholder document layer, propagate the
         // repaint to the native view system.
-        IntRect absRect(r);
-        IntPoint delta;
+        LayoutRect absRect(r);
+        LayoutPoint delta;
         convertToLayerCoords(root(), delta);
         absRect.moveBy(delta);

trunk/Source/WebCore/rendering/RenderLayer.h

@@ -77 +77 @@
     }
 
-    ClipRects(const IntRect& r)
+    ClipRects(const LayoutRect& r)
         : m_overflowClipRect(r)
         , m_fixedClipRect(r)
@@ -95 +95 @@
     }
 
-    void reset(const IntRect& r)
+    void reset(const LayoutRect& r)
     {
         m_overflowClipRect = r;
@@ -103 +103 @@
     }
     
-    const IntRect& overflowClipRect() const { return m_overflowClipRect; }
-    void setOverflowClipRect(const IntRect& r) { m_overflowClipRect = r; }
-
-    const IntRect& fixedClipRect() const { return m_fixedClipRect; }
-    void setFixedClipRect(const IntRect&r) { m_fixedClipRect = r; }
-
-    const IntRect& posClipRect() const { return m_posClipRect; }
-    void setPosClipRect(const IntRect& r) { m_posClipRect = r; }
+    const LayoutRect& overflowClipRect() const { return m_overflowClipRect; }
+    void setOverflowClipRect(const LayoutRect& r) { m_overflowClipRect = r; }
+
+    const LayoutRect& fixedClipRect() const { return m_fixedClipRect; }
+    void setFixedClipRect(const LayoutRect&r) { m_fixedClipRect = r; }
+
+    const LayoutRect& posClipRect() const { return m_posClipRect; }
+    void setPosClipRect(const LayoutRect& r) { m_posClipRect = r; }
 
     bool fixed() const { return m_fixed; }
@@ -148 +148 @@
 
 private:
-    IntRect m_overflowClipRect;
-    IntRect m_fixedClipRect;
-    IntRect m_posClipRect;
+    LayoutRect m_overflowClipRect;
+    LayoutRect m_fixedClipRect;
+    LayoutRect m_posClipRect;
     unsigned m_refCnt : 31;
     bool m_fixed : 1;
@@ -182 +182 @@
     // if layer compositing is being used,
     void setBackingNeedsRepaint();
-    void setBackingNeedsRepaintInRect(const IntRect& r); // r is in the coordinate space of the layer's render object
+    void setBackingNeedsRepaintInRect(const LayoutRect&); // r is in the coordinate space of the layer's render object
     void repaintIncludingNonCompositingDescendants(RenderBoxModelObject* repaintContainer);
 #endif
@@ -220 +220 @@
     LayoutRect rect() const { return LayoutRect(location(), size()); }
 
-    int scrollWidth();
-    int scrollHeight();
-
-    void panScrollFromPoint(const IntPoint&);
+    LayoutUnit scrollWidth();
+    LayoutUnit scrollHeight();
+
+    void panScrollFromPoint(const LayoutPoint&);
 
     // Scrolling methods for layers that can scroll their overflow.
-    void scrollByRecursively(int xDelta, int yDelta);
-
-    IntSize scrolledContentOffset() const { return scrollOffset() + m_scrollOverflow; }
-
-    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 scrollByRecursively(LayoutUnit xDelta, LayoutUnit yDelta);
+
+    LayoutSize scrolledContentOffset() const { return scrollOffset() + m_scrollOverflow; }
+
+    LayoutUnit scrollXOffset() const { return m_scrollOffset.width() + m_scrollOrigin.x(); }
+    LayoutUnit scrollYOffset() const { return m_scrollOffset.height() + m_scrollOrigin.y(); }
+    LayoutSize scrollOffset() const { return LayoutSize(scrollXOffset(), scrollYOffset()); }
 
     enum ScrollOffsetClamping {
@@ -238 +238 @@
         ScrollOffsetClamped
     };
-    void scrollToOffset(int x, int y, 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 IntRect&, const ScrollAlignment& alignX = ScrollAlignment::alignCenterIfNeeded, const ScrollAlignment& alignY = ScrollAlignment::alignCenterIfNeeded);
-
-    IntRect getRectToExpose(const IntRect& visibleRect, const IntRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
+    void scrollToOffset(LayoutUnit, LayoutUnit, ScrollOffsetClamping = ScrollOffsetUnclamped);
+    void scrollToXOffset(LayoutUnit x, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(x, scrollYOffset(), clamp); }
+    void scrollToYOffset(LayoutUnit y, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(scrollXOffset(), y, clamp); }
+
+    void scrollRectToVisible(const LayoutRect&, const ScrollAlignment& alignX = ScrollAlignment::alignCenterIfNeeded, const ScrollAlignment& alignY = ScrollAlignment::alignCenterIfNeeded);
+
+    LayoutRect getRectToExpose(const LayoutRect& visibleRect, const LayoutRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
 
     bool scrollsOverflow() const;
@@ -266 +266 @@
 
     bool hasOverflowControls() const;
-    bool isPointInResizeControl(const IntPoint& absolutePoint) const;
-    bool hitTestOverflowControls(HitTestResult&, const IntPoint& localPoint);
+    bool isPointInResizeControl(const LayoutPoint& absolutePoint) const;
+    bool hitTestOverflowControls(HitTestResult&, const LayoutPoint& localPoint);
     LayoutSize offsetFromResizeCorner(const LayoutPoint& absolutePoint) const;
 
@@ -308 +308 @@
     };
     typedef unsigned UpdateLayerPositionsFlags;
-    void updateLayerPositions(UpdateLayerPositionsFlags = CheckForRepaint | IsCompositingUpdateRoot | UpdateCompositingLayers, IntPoint* cachedOffset = 0);
+    void updateLayerPositions(UpdateLayerPositionsFlags = CheckForRepaint | IsCompositingUpdateRoot | UpdateCompositingLayers, LayoutPoint* cachedOffset = 0);
 
     void updateTransform();
 
-    void relativePositionOffset(int& relX, int& relY) const { relX += m_relativeOffset.width(); relY += m_relativeOffset.height(); }
-    const IntSize& relativePositionOffset() const { return m_relativeOffset; }
+    void relativePositionOffset(LayoutUnit& relX, LayoutUnit& relY) const { relX += m_relativeOffset.width(); relY += m_relativeOffset.height(); }
+    const LayoutSize& relativePositionOffset() const { return m_relativeOffset; }
 
     void clearClipRectsIncludingDescendants();
     void clearClipRects();
 
-    void addBlockSelectionGapsBounds(const IntRect&);
+    void addBlockSelectionGapsBounds(const LayoutRect&);
     void clearBlockSelectionGapsBounds();
     void repaintBlockSelectionGaps();
@@ -359 +359 @@
 #endif
 
-    void convertToLayerCoords(const RenderLayer* ancestorLayer, IntPoint& location) const;
-    void convertToLayerCoords(const RenderLayer* ancestorLayer, IntRect& rect) const;
+    void convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutPoint& location) const;
+    void convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect&) const;
 
     bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); }
@@ -369 +369 @@
     // front.  The hitTest method looks for mouse events by walking
     // layers that intersect the point from front to back.
-    void paint(GraphicsContext*, const IntRect& damageRect, PaintBehavior = PaintBehaviorNormal, RenderObject* paintingRoot = 0);
+    void paint(GraphicsContext*, const LayoutRect& damageRect, PaintBehavior = PaintBehaviorNormal, RenderObject* paintingRoot = 0);
     bool hitTest(const HitTestRequest&, HitTestResult&);
-    void paintOverlayScrollbars(GraphicsContext*, const IntRect& damageRect, PaintBehavior, RenderObject* paintingRoot);
+    void paintOverlayScrollbars(GraphicsContext*, const LayoutRect& damageRect, PaintBehavior, RenderObject* paintingRoot);
 
     // This method figures out our layerBounds in coordinates relative to
@@ -387 +387 @@
     ClipRects* clipRects() const { return m_clipRects; }
 
-    IntRect childrenClipRect() const; // Returns the foreground clip rect of the layer in the document's coordinate space.
-    IntRect selfClipRect() const; // Returns the background clip rect of the layer in the document's coordinate space.
-
-    bool intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect, const RenderLayer* rootLayer) const;
+    LayoutRect childrenClipRect() const; // Returns the foreground clip rect of the layer in the document's coordinate space.
+    LayoutRect selfClipRect() const; // Returns the background clip rect of the layer in the document's coordinate space.
+
+    bool intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer) const;
 
     // Bounding box relative to some ancestor layer.
-    IntRect boundingBox(const RenderLayer* rootLayer) const;
+    LayoutRect boundingBox(const RenderLayer* rootLayer) const;
     // Bounding box in the coordinates of this layer.
-    IntRect localBoundingBox() const;
+    LayoutRect localBoundingBox() const;
     // Bounding box relative to the root.
-    IntRect absoluteBoundingBox() const;
+    LayoutRect absoluteBoundingBox() const;
 
     void updateHoverActiveState(const HitTestRequest&, HitTestResult&);
 
     // Return a cached repaint rect, computed relative to the layer renderer's containerForRepaint.
-    IntRect repaintRect() const { return m_repaintRect; }
-    IntRect repaintRectIncludingDescendants() const;
+    LayoutRect repaintRect() const { return m_repaintRect; }
+    LayoutRect repaintRectIncludingDescendants() const;
     void computeRepaintRects();
     void updateRepaintRectsAfterScroll(bool fixed = false);
@@ -490 +490 @@
     typedef unsigned PaintLayerFlags;
 
-    void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect,
+    void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect,
                     PaintBehavior, RenderObject* paintingRoot, OverlapTestRequestMap* = 0,
                     PaintLayerFlags = 0);
     void paintList(Vector<RenderLayer*>*, RenderLayer* rootLayer, GraphicsContext* p,
-                   const IntRect& paintDirtyRect, PaintBehavior,
+                   const LayoutRect& paintDirtyRect, PaintBehavior,
                    RenderObject* paintingRoot, OverlapTestRequestMap*,
                    PaintLayerFlags);
     void paintPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext*,
-                                  const IntRect& paintDirtyRect, PaintBehavior,
+                                  const LayoutRect& paintDirtyRect, PaintBehavior,
                                   RenderObject* paintingRoot, OverlapTestRequestMap*,
                                   PaintLayerFlags);
     void paintChildLayerIntoColumns(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext*,
-                                    const IntRect& paintDirtyRect, PaintBehavior,
+                                    const LayoutRect& paintDirtyRect, PaintBehavior,
                                     RenderObject* paintingRoot, OverlapTestRequestMap*,
                                     PaintLayerFlags, const Vector<RenderLayer*>& columnLayers, size_t columnIndex);
@@ -531 +531 @@
     bool shouldBeNormalFlowOnly() const; 
 
-    int scrollPosition(Scrollbar*) const;
+    LayoutUnit scrollPosition(Scrollbar*) const;
     
     // ScrollableArea interface
-    virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&);
-    virtual void invalidateScrollCornerRect(const IntRect&);
+    virtual void invalidateScrollbarRect(Scrollbar*, const LayoutRect&);
+    virtual void invalidateScrollCornerRect(const LayoutRect&);
     virtual bool isActive() const;
     virtual bool isScrollCornerVisible() const;
-    virtual IntRect scrollCornerRect() const;
-    virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const;
-    virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const;
-    virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const;
-    virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const;
-    virtual int scrollSize(ScrollbarOrientation) const;
-    virtual void setScrollOffset(const IntPoint&);
-    virtual IntPoint scrollPosition() const;
-    virtual IntPoint minimumScrollPosition() const;
-    virtual IntPoint maximumScrollPosition() const;
-    virtual IntRect visibleContentRect(bool includeScrollbars) const;
+    virtual LayoutRect scrollCornerRect() const;
+    virtual LayoutRect convertFromScrollbarToContainingView(const Scrollbar*, const LayoutRect&) const;
+    virtual LayoutRect convertFromContainingViewToScrollbar(const Scrollbar*, const LayoutRect&) const;
+    virtual LayoutPoint convertFromScrollbarToContainingView(const Scrollbar*, const LayoutPoint&) const;
+    virtual LayoutPoint convertFromContainingViewToScrollbar(const Scrollbar*, const LayoutPoint&) const;
+    virtual LayoutUnit scrollSize(ScrollbarOrientation) const;
+    virtual void setScrollOffset(const LayoutPoint&);
+    virtual LayoutPoint scrollPosition() const;
+    virtual LayoutPoint minimumScrollPosition() const;
+    virtual LayoutPoint maximumScrollPosition() const;
+    virtual LayoutRect visibleContentRect(bool includeScrollbars) const;
     virtual LayoutUnit visibleHeight() const;
     virtual LayoutUnit visibleWidth() const;
-    virtual IntSize contentsSize() const;
-    virtual IntSize overhangAmount() const;
-    virtual IntPoint currentMousePosition() const;
-    virtual void didCompleteRubberBand(const IntSize&) const;
+    virtual LayoutSize contentsSize() const;
+    virtual LayoutSize overhangAmount() const;
+    virtual LayoutPoint currentMousePosition() const;
+    virtual void didCompleteRubberBand(const LayoutSize&) const;
     virtual bool shouldSuspendScrollAnimations() const;
     virtual bool isOnActivePage() const;
 
     // Rectangle encompassing the scroll corner and resizer rect.
-    IntRect scrollCornerAndResizerRect() const;
+    LayoutRect scrollCornerAndResizerRect() const;
 
     virtual void disconnectFromPage() { m_scrollableAreaPage = 0; }
 
     // NOTE: This should only be called by the overriden setScrollOffset from ScrollableArea.
-    void scrollTo(int x, int y);
-
-    IntSize scrollbarOffset(const Scrollbar*) const;
+    void scrollTo(LayoutUnit, LayoutUnit);
+
+    LayoutSize scrollbarOffset(const Scrollbar*) const;
     
     void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
@@ -592 +592 @@
     
     void parentClipRects(const RenderLayer* rootLayer, ClipRects&, bool temporaryClipRects = false, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
-    IntRect backgroundClipRect(const RenderLayer* rootLayer, bool temporaryClipRects, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
+    LayoutRect backgroundClipRect(const RenderLayer* rootLayer, bool temporaryClipRects, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
 
     RenderLayer* enclosingTransformedAncestor() const;
 
     // Convert a point in absolute coords into layer coords, taking transforms into account
-    IntPoint absoluteToContents(const IntPoint&) const;
-
-    void positionOverflowControls(const IntSize&);
+    LayoutPoint absoluteToContents(const LayoutPoint&) const;
+
+    void positionOverflowControls(const LayoutSize&);
     void updateScrollCornerStyle();
     void updateResizerStyle();
@@ -621 +621 @@
     void destroy(RenderArena*);
 
-    int overflowTop() const;
-    int overflowBottom() const;
-    int overflowLeft() const;
-    int overflowRight() const;
+    LayoutUnit overflowTop() const;
+    LayoutUnit overflowBottom() const;
+    LayoutUnit overflowLeft() const;
+    LayoutUnit overflowRight() const;
 
 protected:
@@ -635 +635 @@
     RenderLayer* m_last;
 
-    IntRect m_repaintRect; // Cached repaint rects. Used by layout.
-    IntRect m_outlineBox;
+    LayoutRect m_repaintRect; // Cached repaint rects. Used by layout.
+    LayoutRect m_outlineBox;
 
     // Our current relative position offset.
-    IntSize m_relativeOffset;
+    LayoutSize m_relativeOffset;
 
     // Our (x,y) coordinates are in our parent layer's coordinate space.
@@ -648 +648 @@
 
     // Our scroll offsets if the view is scrolled.
-    IntSize m_scrollOffset;
-
-    IntSize m_scrollOverflow;
+    LayoutSize m_scrollOffset;
+
+    LayoutSize m_scrollOverflow;
     
     // The width/height of our scrolled area.
-    IntSize m_scrollSize;
+    LayoutSize m_scrollSize;
 
     // For layers with overflow, we have a pair of scrollbars.
@@ -710 +710 @@
     bool m_containsDirtyOverlayScrollbars : 1;
 
-    IntPoint m_cachedOverlayScrollbarOffset;
+    LayoutPoint m_cachedOverlayScrollbarOffset;
 
     RenderMarquee* m_marquee; // Used by layers with overflow:marquee
@@ -728 +728 @@
 
 private:
-    IntRect m_blockSelectionGapsBounds;
+    LayoutRect m_blockSelectionGapsBounds;
 
 #if USE(ACCELERATED_COMPOSITING)

trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

@@ -66 +66 @@
 static bool hasBoxDecorationsOrBackground(const RenderObject*);
 static bool hasBoxDecorationsOrBackgroundImage(const RenderStyle*);
-static IntRect clipBox(RenderBox* renderer);
+static LayoutRect clipBox(RenderBox* renderer);
 
 static inline bool isAcceleratedCanvas(RenderObject* renderer)
@@ -192 +192 @@
 void RenderLayerBacking::updateCompositedBounds()
 {
-    IntRect layerBounds = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer);
+    LayoutRect layerBounds = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer);
 
     // Clip to the size of the document or enclosing overflow-scroll layer.
@@ -208 +208 @@
 
         // Start by clipping to the view's bounds.
-        IntRect clippingBounds = view->layoutOverflowRect();
+        LayoutRect clippingBounds = view->layoutOverflowRect();
 
         if (m_owningLayer != rootLayer)
             clippingBounds.intersect(m_owningLayer->backgroundClipRect(rootLayer, true));
 
-        IntPoint delta;
+        LayoutPoint delta;
         m_owningLayer->convertToLayerCoords(rootLayer, delta);
         clippingBounds.move(-delta.x(), -delta.y());
@@ -334 +334 @@
 }
 
-static IntRect clipBox(RenderBox* renderer)
-{
-    IntRect result = PaintInfo::infiniteRect();
+static LayoutRect clipBox(RenderBox* renderer)
+{
+    LayoutRect result = PaintInfo::infiniteRect();
     if (renderer->hasOverflowClip())
-        result = renderer->overflowClipRect(IntPoint());
+        result = renderer->overflowClipRect(LayoutPoint());
 
     if (renderer->hasClip())
-        result.intersect(renderer->clipRect(IntPoint()));
+        result.intersect(renderer->clipRect(LayoutPoint()));
 
     return result;
@@ -368 +368 @@
     
     // We compute everything relative to the enclosing compositing layer.
-    IntRect ancestorCompositingBounds;
+    LayoutRect ancestorCompositingBounds;
     if (compAncestor) {
         ASSERT(compAncestor->backing());
@@ -374 +374 @@
     }
 
-    IntRect localCompositingBounds = compositedBounds();
-
-    IntRect relativeCompositingBounds(localCompositingBounds);
-    IntPoint delta;
+    LayoutRect localCompositingBounds = compositedBounds();
+
+    LayoutRect relativeCompositingBounds(localCompositingBounds);
+    LayoutPoint delta;
     m_owningLayer->convertToLayerCoords(compAncestor, delta);
     relativeCompositingBounds.moveBy(delta);
 
-    IntPoint graphicsLayerParentLocation;
+    LayoutPoint graphicsLayerParentLocation;
     if (compAncestor && compAncestor->backing()->hasClippingLayer()) {
         // If the compositing ancestor has a layer to clip children, we parent in that, and therefore
         // position relative to it.
-        IntRect clippingBox = clipBox(toRenderBox(compAncestor->renderer()));
+        LayoutRect clippingBox = clipBox(toRenderBox(compAncestor->renderer()));
         graphicsLayerParentLocation = clippingBox.location();
     } else if (compAncestor)
@@ -396 +396 @@
         // layer. Note that we call it with temporaryClipRects = true because normally when computing clip rects
         // for a compositing layer, rootLayer is the layer itself.
-        IntRect parentClipRect = m_owningLayer->backgroundClipRect(compAncestor, true);
+        LayoutRect parentClipRect = m_owningLayer->backgroundClipRect(compAncestor, true);
         ASSERT(parentClipRect != PaintInfo::infiniteRect());
         m_ancestorClippingLayer->setPosition(FloatPoint() + (parentClipRect.location() - graphicsLayerParentLocation));
@@ -410 +410 @@
     m_graphicsLayer->setPosition(FloatPoint() + (relativeCompositingBounds.location() - graphicsLayerParentLocation));
     
-    IntSize oldOffsetFromRenderer = m_graphicsLayer->offsetFromRenderer();
-    m_graphicsLayer->setOffsetFromRenderer(localCompositingBounds.location() - IntPoint());
+    LayoutSize oldOffsetFromRenderer = m_graphicsLayer->offsetFromRenderer();
+    m_graphicsLayer->setOffsetFromRenderer(localCompositingBounds.location() - LayoutPoint());
     
     // If the compositing layer offset changes, we need to repaint.
@@ -428 +428 @@
 
     // If we have a layer that clips children, position it.
-    IntRect clippingBox;
+    LayoutRect clippingBox;
     if (m_clippingLayer) {
         clippingBox = clipBox(toRenderBox(renderer()));
         m_clippingLayer->setPosition(FloatPoint() + (clippingBox.location() - localCompositingBounds.location()));
         m_clippingLayer->setSize(clippingBox.size());
-        m_clippingLayer->setOffsetFromRenderer(clippingBox.location() - IntPoint());
+        m_clippingLayer->setOffsetFromRenderer(clippingBox.location() - LayoutPoint());
     }
     
@@ -446 +446 @@
     
     if (m_owningLayer->hasTransform()) {
-        const IntRect borderBox = toRenderBox(renderer())->borderBoxRect();
+        const LayoutRect borderBox = toRenderBox(renderer())->borderBoxRect();
 
         // Get layout bounds in the coords of compAncestor to match relativeCompositingBounds.
-        IntRect layerBounds = IntRect(delta, borderBox.size());
+        LayoutRect layerBounds = LayoutRect(delta, borderBox.size());
 
         // Update properties that depend on layer dimensions
@@ -482 +482 @@
         FloatPoint foregroundPosition;
         FloatSize foregroundSize = newSize;
-        IntSize foregroundOffset = m_graphicsLayer->offsetFromRenderer();
+        LayoutSize foregroundOffset = m_graphicsLayer->offsetFromRenderer();
         if (m_clippingLayer) {
             // If we have a clipping layer (which clips descendants), then the foreground layer is a child of it,
             // so that it gets correctly sorted with children. In that case, position relative to the clipping layer.
             foregroundSize = FloatSize(clippingBox.size());
-            foregroundOffset = clippingBox.location() - IntPoint();
+            foregroundOffset = clippingBox.location() - LayoutPoint();
         }
 
@@ -986 +986 @@
 }
 
-FloatPoint3D RenderLayerBacking::computeTransformOrigin(const IntRect& borderBox) const
+FloatPoint3D RenderLayerBacking::computeTransformOrigin(const LayoutRect& borderBox) const
 {
     RenderStyle* style = renderer()->style();
@@ -998 +998 @@
 }
 
-FloatPoint RenderLayerBacking::computePerspectiveOrigin(const IntRect& borderBox) const
+FloatPoint RenderLayerBacking::computePerspectiveOrigin(const LayoutRect& borderBox) const
 {
     RenderStyle* style = renderer()->style();
@@ -1013 +1013 @@
 
 // Return the offset from the top-left of this compositing layer at which the renderer's contents are painted.
-IntSize RenderLayerBacking::contentOffsetInCompostingLayer() const
-{
-    return IntSize(-m_compositedBounds.x(), -m_compositedBounds.y());
-}
-
-IntRect RenderLayerBacking::contentsBox() const
+LayoutSize RenderLayerBacking::contentOffsetInCompostingLayer() const
+{
+    return LayoutSize(-m_compositedBounds.x(), -m_compositedBounds.y());
+}
+
+LayoutRect RenderLayerBacking::contentsBox() const
 {
     if (!renderer()->isBox())
-        return IntRect();
-
-    IntRect contentsRect;
+        return LayoutRect();
+
+    LayoutRect contentsRect;
 #if ENABLE(VIDEO)
     if (renderer()->isVideo()) {
@@ -1032 +1032 @@
         contentsRect = toRenderBox(renderer())->contentBoxRect();
 
-    IntSize contentOffset = contentOffsetInCompostingLayer();
+    LayoutSize contentOffset = contentOffsetInCompostingLayer();
     contentsRect.move(contentOffset);
     return contentsRect;
@@ -1058 +1058 @@
 
 // r is in the coordinate space of the layer's render object
-void RenderLayerBacking::setContentsNeedDisplayInRect(const IntRect& r)
+void RenderLayerBacking::setContentsNeedDisplayInRect(const LayoutRect& r)
 {
     if (m_graphicsLayer && m_graphicsLayer->drawsContent()) {
-        IntRect layerDirtyRect = r;
+        LayoutRect layerDirtyRect = r;
         layerDirtyRect.move(-m_graphicsLayer->offsetFromRenderer());
         m_graphicsLayer->setNeedsDisplayInRect(layerDirtyRect);
@@ -1067 +1067 @@
 
     if (m_foregroundLayer && m_foregroundLayer->drawsContent()) {
-        IntRect layerDirtyRect = r;
+        LayoutRect layerDirtyRect = r;
         layerDirtyRect.move(-m_foregroundLayer->offsetFromRenderer());
         m_foregroundLayer->setNeedsDisplayInRect(layerDirtyRect);
@@ -1073 +1073 @@
 
     if (m_maskLayer && m_maskLayer->drawsContent()) {
-        IntRect layerDirtyRect = r;
+        LayoutRect layerDirtyRect = r;
         layerDirtyRect.move(-m_maskLayer->offsetFromRenderer());
         m_maskLayer->setNeedsDisplayInRect(layerDirtyRect);
@@ -1079 +1079 @@
 }
 
-static void setClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect)
+static void setClip(GraphicsContext* p, const LayoutRect& paintDirtyRect, const LayoutRect& clipRect)
 {
     if (paintDirtyRect == clipRect)
@@ -1087 +1087 @@
 }
 
-static void restoreClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect)
+static void restoreClip(GraphicsContext* p, const LayoutRect& paintDirtyRect, const LayoutRect& clipRect)
 {
     if (paintDirtyRect == clipRect)
@@ -1096 +1096 @@
 // Share this with RenderLayer::paintLayer, which would have to be educated about GraphicsLayerPaintingPhase?
 void RenderLayerBacking::paintIntoLayer(RenderLayer* rootLayer, GraphicsContext* context,
-                    const IntRect& paintDirtyRect,      // in the coords of rootLayer
+                    const LayoutRect& paintDirtyRect, // In the coords of rootLayer.
                     PaintBehavior paintBehavior, GraphicsLayerPaintingPhase paintingPhase,
                     RenderObject* paintingRoot)
@@ -1108 +1108 @@
     
     // Calculate the clip rects we should use.
-    IntRect layerBounds, damageRect, clipRectToApply, outlineRect;
+    LayoutRect layerBounds, damageRect, clipRectToApply, outlineRect;
     m_owningLayer->calculateRects(rootLayer, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect);
 
-    IntPoint paintOffset = toPoint(layerBounds.location() - m_owningLayer->renderBoxLocation());
+    LayoutPoint paintOffset = toPoint(layerBounds.location() - m_owningLayer->renderBoxLocation());
 
     // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which
@@ -1199 +1199 @@
 }
 
-static void paintScrollbar(Scrollbar* scrollbar, GraphicsContext& context, const IntRect& clip)
+static void paintScrollbar(Scrollbar* scrollbar, GraphicsContext& context, const LayoutRect& clip)
 {
     if (!scrollbar)
@@ -1205 +1205 @@
 
     context.save();
-    const IntRect& scrollbarRect = scrollbar->frameRect();
+    const LayoutRect& scrollbarRect = scrollbar->frameRect();
     context.translate(-scrollbarRect.x(), -scrollbarRect.y());
-    IntRect transformedClip = clip;
+    LayoutRect transformedClip = clip;
     transformedClip.moveBy(scrollbarRect.location());
     scrollbar->paint(&context, transformedClip);
@@ -1214 +1214 @@
 
 // Up-call from compositing layer drawing callback.
-void RenderLayerBacking::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase paintingPhase, const IntRect& clip)
+void RenderLayerBacking::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase paintingPhase, const LayoutRect& clip)
 {
     if (graphicsLayer == m_graphicsLayer.get() || graphicsLayer == m_foregroundLayer.get() || graphicsLayer == m_maskLayer.get()) {
         InspectorInstrumentationCookie cookie = InspectorInstrumentation::willPaint(m_owningLayer->renderer()->frame(), clip);
 
-        IntSize offset = graphicsLayer->offsetFromRenderer();
+        LayoutSize offset = graphicsLayer->offsetFromRenderer();
         context.translate(-offset);
 
-        IntRect clipRect(clip);
+        LayoutRect clipRect(clip);
         clipRect.move(offset);
 
         // The dirtyRect is in the coords of the painting root.
-        IntRect dirtyRect = compositedBounds();
+        LayoutRect dirtyRect = compositedBounds();
         dirtyRect.intersect(clipRect);
 
@@ -1238 +1238 @@
         paintScrollbar(m_owningLayer->verticalScrollbar(), context, clip);
     } else if (graphicsLayer == layerForScrollCorner()) {
-        const IntRect& scrollCornerAndResizer = m_owningLayer->scrollCornerAndResizerRect();
+        const LayoutRect& scrollCornerAndResizer = m_owningLayer->scrollCornerAndResizerRect();
         context.save();
         context.translate(-scrollCornerAndResizer.x(), -scrollCornerAndResizer.y());
-        IntRect transformedClip = clip;
+        LayoutRect transformedClip = clip;
         transformedClip.moveBy(scrollCornerAndResizer.location());
-        m_owningLayer->paintScrollCorner(&context, IntPoint(), transformedClip);
-        m_owningLayer->paintResizer(&context, IntPoint(), transformedClip);
+        m_owningLayer->paintScrollCorner(&context, LayoutPoint(), transformedClip);
+        m_owningLayer->paintResizer(&context, LayoutPoint(), transformedClip);
         context.restore();
     }
@@ -1313 +1313 @@
     }
 
-    if (hasOpacity && m_graphicsLayer->addAnimation(opacityVector, IntSize(), anim, keyframes.animationName(), timeOffset)) {
+    if (hasOpacity && m_graphicsLayer->addAnimation(opacityVector, LayoutSize(), anim, keyframes.animationName(), timeOffset)) {
         didAnimateOpacity = true;
         compositor()->didStartAcceleratedAnimation(CSSPropertyOpacity);
@@ -1344 +1344 @@
             opacityVector.insert(new FloatAnimationValue(1, compositingOpacity(toStyle->opacity())));
             // The boxSize param is only used for transform animations (which can only run on RenderBoxes), so we pass an empty size here.
-            if (m_graphicsLayer->addAnimation(opacityVector, IntSize(), opacityAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyOpacity), timeOffset)) {
+            if (m_graphicsLayer->addAnimation(opacityVector, LayoutSize(), opacityAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyOpacity), timeOffset)) {
                 // To ensure that the correct opacity is visible when the animation ends, also set the final opacity.
                 updateLayerOpacity(toStyle);
@@ -1411 +1411 @@
 }
 
-IntRect RenderLayerBacking::compositedBounds() const
+LayoutRect RenderLayerBacking::compositedBounds() const
 {
     return m_compositedBounds;
 }
 
-void RenderLayerBacking::setCompositedBounds(const IntRect& bounds)
+void RenderLayerBacking::setCompositedBounds(const LayoutRect& bounds)
 {
     m_compositedBounds = bounds;

trunk/Source/WebCore/rendering/RenderLayerBacking.h

@@ -100 +100 @@
     void setContentsNeedDisplay();
     // r is in the coordinate space of the layer's render object
-    void setContentsNeedDisplayInRect(const IntRect& r);
+    void setContentsNeedDisplayInRect(const LayoutRect&);
 
     // Notification from the renderer that its content changed.
@@ -117 +117 @@
     void resumeAnimations();
 
-    IntRect compositedBounds() const;
-    void setCompositedBounds(const IntRect&);
+    LayoutRect compositedBounds() const;
+    void setCompositedBounds(const LayoutRect&);
     void updateCompositedBounds();
     
@@ -127 +127 @@
     virtual void notifySyncRequired(const GraphicsLayer*);
 
-    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect& clip);
+    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const LayoutRect& clip);
 
     virtual float deviceScaleFactor() const;
@@ -136 +136 @@
     virtual bool showRepaintCounter() const;
 
-    IntRect contentsBox() const;
+    LayoutRect contentsBox() const;
     
     // For informative purposes only.
@@ -165 +165 @@
     GraphicsLayerPaintingPhase paintingPhaseForPrimaryLayer() const;
     
-    IntSize contentOffsetInCompostingLayer() const;
+    LayoutSize contentOffsetInCompostingLayer() const;
     // Result is transform origin in pixels.
-    FloatPoint3D computeTransformOrigin(const IntRect& borderBox) const;
+    FloatPoint3D computeTransformOrigin(const LayoutRect& borderBox) const;
     // Result is perspective origin in pixels.
-    FloatPoint computePerspectiveOrigin(const IntRect& borderBox) const;
+    FloatPoint computePerspectiveOrigin(const LayoutRect& borderBox) const;
 
     void updateLayerOpacity(const RenderStyle*);
@@ -191 +191 @@
     bool hasNonCompositingDescendants() const;
     
-    void paintIntoLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect, PaintBehavior, GraphicsLayerPaintingPhase, RenderObject* paintingRoot);
+    void paintIntoLayer(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, PaintBehavior, GraphicsLayerPaintingPhase, RenderObject* paintingRoot);
 
     static int graphicsLayerToCSSProperty(AnimatedPropertyID);
@@ -212 +212 @@
     OwnPtr<GraphicsLayer> m_layerForScrollCorner;
 
-    IntRect m_compositedBounds;
+    LayoutRect m_compositedBounds;
 
     bool m_artificiallyInflatedBounds;      // bounds had to be made non-zero to make transform-origin work

trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

@@ -440 +440 @@
 // The bounds of the GraphicsLayer created for a compositing layer is the union of the bounds of all the descendant
 // RenderLayers that are rendered by the composited RenderLayer.
-IntRect RenderLayerCompositor::calculateCompositedBounds(const RenderLayer* layer, const RenderLayer* ancestorLayer)
+LayoutRect RenderLayerCompositor::calculateCompositedBounds(const RenderLayer* layer, const RenderLayer* ancestorLayer)
 {
     if (!canBeComposited(layer))
-        return IntRect();
-
-    IntRect boundingBoxRect = layer->localBoundingBox();
+        return LayoutRect();
+
+    LayoutRect boundingBoxRect = layer->localBoundingBox();
     if (layer->renderer()->isRoot()) {
         // If the root layer becomes composited (e.g. because some descendant with negative z-index is composited),
@@ -459 +459 @@
     }
     
-    IntRect unionBounds = boundingBoxRect;
+    LayoutRect unionBounds = boundingBoxRect;
     
     if (layer->renderer()->hasOverflowClip() || layer->renderer()->hasMask()) {
-        IntPoint ancestorRelOffset;
+        LayoutPoint ancestorRelOffset;
         layer->convertToLayerCoords(ancestorLayer, ancestorRelOffset);
         boundingBoxRect.moveBy(ancestorRelOffset);
@@ -470 +470 @@
     if (RenderLayer* reflection = layer->reflectionLayer()) {
         if (!reflection->isComposited()) {
-            IntRect childUnionBounds = calculateCompositedBounds(reflection, layer);
+            LayoutRect childUnionBounds = calculateCompositedBounds(reflection, layer);
             unionBounds.unite(childUnionBounds);
         }
@@ -482 +482 @@
             RenderLayer* curLayer = negZOrderList->at(i);
             if (!curLayer->isComposited()) {
-                IntRect childUnionBounds = calculateCompositedBounds(curLayer, layer);
+                LayoutRect childUnionBounds = calculateCompositedBounds(curLayer, layer);
                 unionBounds.unite(childUnionBounds);
             }
@@ -493 +493 @@
             RenderLayer* curLayer = posZOrderList->at(i);
             if (!curLayer->isComposited()) {
-                IntRect childUnionBounds = calculateCompositedBounds(curLayer, layer);
+                LayoutRect childUnionBounds = calculateCompositedBounds(curLayer, layer);
                 unionBounds.unite(childUnionBounds);
             }
@@ -504 +504 @@
             RenderLayer* curLayer = normalFlowList->at(i);
             if (!curLayer->isComposited()) {
-                IntRect curAbsBounds = calculateCompositedBounds(curLayer, layer);
+                LayoutRect curAbsBounds = calculateCompositedBounds(curLayer, layer);
                 unionBounds.unite(curAbsBounds);
             }
@@ -516 +516 @@
     }
 
-    IntPoint ancestorRelOffset;
+    LayoutPoint ancestorRelOffset;
     layer->convertToLayerCoords(ancestorLayer, ancestorRelOffset);
     unionBounds.moveBy(ancestorRelOffset);
@@ -538 +538 @@
     if (compLayer) {
         ASSERT(compLayer->backing());
-        IntRect compBounds = child->backing()->compositedBounds();
-
-        IntPoint offset;
+        LayoutRect compBounds = child->backing()->compositedBounds();
+
+        LayoutPoint offset;
         child->convertToLayerCoords(compLayer, offset);
         compBounds.moveBy(offset);
@@ -566 +566 @@
 }
 
-void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, RenderLayer* layer, IntRect& layerBounds, bool& boundsComputed)
+void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, RenderLayer* layer, LayoutRect& layerBounds, bool& boundsComputed)
 {
     if (layer->isRootLayer())
@@ -575 +575 @@
         // Empty rects never intersect, but we need them to for the purposes of overlap testing.
         if (layerBounds.isEmpty())
-            layerBounds.setSize(IntSize(1, 1));
+            layerBounds.setSize(LayoutSize(1, 1));
         boundsComputed = true;
     }
 
-    IntRect clipRect = layer->backgroundClipRect(rootRenderLayer(), true);
+    LayoutRect clipRect = layer->backgroundClipRect(rootRenderLayer(), true);
     clipRect.intersect(layerBounds);
     overlapMap.add(layer, clipRect);
@@ -589 +589 @@
         return;
 
-    IntRect bounds;
+    LayoutRect bounds;
     bool haveComputedBounds = false;
     addToOverlapMap(overlapMap, layer, bounds, haveComputedBounds);
@@ -623 +623 @@
 }
 
-bool RenderLayerCompositor::overlapsCompositedLayers(OverlapMap& overlapMap, const IntRect& layerBounds)
+bool RenderLayerCompositor::overlapsCompositedLayers(OverlapMap& overlapMap, const LayoutRect& layerBounds)
 {
     RenderLayerCompositor::OverlapMap::const_iterator end = overlapMap.end();
     for (RenderLayerCompositor::OverlapMap::const_iterator it = overlapMap.begin(); it != end; ++it) {
-        const IntRect& bounds = it->second;
+        const LayoutRect& bounds = it->second;
         if (layerBounds.intersects(bounds))
             return true;
@@ -656 +656 @@
 
     bool haveComputedBounds = false;
-    IntRect absBounds;
+    LayoutRect absBounds;
     if (overlapMap && !overlapMap->isEmpty()) {
         // If we're testing for overlap, we only need to composite if we overlap something that is already composited.
@@ -662 +662 @@
         // Empty rects never intersect, but we need them to for the purposes of overlap testing.
         if (absBounds.isEmpty())
-            absBounds.setSize(IntSize(1, 1));
+            absBounds.setSize(LayoutSize(1, 1));
         haveComputedBounds = true;
         mustOverlapCompositedLayers = overlapsCompositedLayers(*overlapMap, absBounds);
@@ -947 +947 @@
 }
 
-void RenderLayerCompositor::frameViewDidChangeLocation(const IntPoint& contentsOffset)
+void RenderLayerCompositor::frameViewDidChangeLocation(const LayoutPoint& contentsOffset)
 {
     if (m_overflowControlsHostLayer)
@@ -959 +959 @@
         m_clipLayer->setSize(frameView->visibleContentRect(false /* exclude scrollbars */).size());
 
-        IntPoint scrollPosition = frameView->scrollPosition();
+        LayoutPoint scrollPosition = frameView->scrollPosition();
         m_scrollLayer->setPosition(FloatPoint(-scrollPosition.x(), -scrollPosition.y()));
         updateOverflowControlsLayers();
@@ -965 +965 @@
 }
 
-void RenderLayerCompositor::frameViewDidScroll(const IntPoint& scrollPosition)
+void RenderLayerCompositor::frameViewDidScroll(const LayoutPoint& scrollPosition)
 {
     if (m_scrollLayer)
@@ -1111 +1111 @@
 
 
-void RenderLayerCompositor::repaintCompositedLayersAbsoluteRect(const IntRect& absRect)
+void RenderLayerCompositor::repaintCompositedLayersAbsoluteRect(const LayoutRect& absRect)
 {
     recursiveRepaintLayerRect(rootRenderLayer(), absRect);
 }
 
-void RenderLayerCompositor::recursiveRepaintLayerRect(RenderLayer* layer, const IntRect& rect)
+void RenderLayerCompositor::recursiveRepaintLayerRect(RenderLayer* layer, const LayoutRect& rect)
 {
     // FIXME: This method does not work correctly with transforms.
@@ -1127 +1127 @@
             for (size_t i = 0; i < listSize; ++i) {
                 RenderLayer* curLayer = negZOrderList->at(i);
-                IntRect childRect(rect);
+                LayoutRect childRect(rect);
                 curLayer->convertToLayerCoords(layer, childRect);
                 recursiveRepaintLayerRect(curLayer, childRect);
@@ -1137 +1137 @@
             for (size_t i = 0; i < listSize; ++i) {
                 RenderLayer* curLayer = posZOrderList->at(i);
-                IntRect childRect(rect);
+                LayoutRect childRect(rect);
                 curLayer->convertToLayerCoords(layer, childRect);
                 recursiveRepaintLayerRect(curLayer, childRect);
@@ -1147 +1147 @@
         for (size_t i = 0; i < listSize; ++i) {
             RenderLayer* curLayer = normalFlowList->at(i);
-            IntRect childRect(rect);
+            LayoutRect childRect(rect);
             curLayer->convertToLayerCoords(layer, childRect);
             recursiveRepaintLayerRect(curLayer, childRect);
@@ -1203 +1203 @@
 {
     if (m_rootContentLayer) {
-        const IntRect& documentRect = m_renderView->documentRect();
+        const LayoutRect& documentRect = m_renderView->documentRect();
         m_rootContentLayer->setSize(documentRect.size());
         m_rootContentLayer->setPosition(documentRect.location());
@@ -1347 +1347 @@
         return false;
 
-    IntRect backgroundRect = layer->backgroundClipRect(computeClipRoot, true);
+    LayoutRect backgroundRect = layer->backgroundClipRect(computeClipRoot, true);
     return backgroundRect != PaintInfo::infiniteRect();
 }
@@ -1438 +1438 @@
 
     // Don't go into compositing mode if height or width are zero, or size is 1x1.
-    IntRect contentBox = pluginRenderer->contentBoxRect();
+    LayoutRect contentBox = pluginRenderer->contentBoxRect();
     return contentBox.height() * contentBox.width() > 1;
 }
@@ -1463 +1463 @@
     
     // Don't go into compositing mode if height or width are zero.
-    IntRect contentBox = frameRenderer->contentBoxRect();
+    LayoutRect contentBox = frameRenderer->contentBoxRect();
     return contentBox.height() * contentBox.width() > 0;
 }
@@ -1523 +1523 @@
 }
 
-static void paintScrollbar(Scrollbar* scrollbar, GraphicsContext& context, const IntRect& clip)
+static void paintScrollbar(Scrollbar* scrollbar, GraphicsContext& context, const LayoutRect& clip)
 {
     if (!scrollbar)
@@ -1529 +1529 @@
 
     context.save();
-    const IntRect& scrollbarRect = scrollbar->frameRect();
+    const LayoutRect& scrollbarRect = scrollbar->frameRect();
     context.translate(-scrollbarRect.x(), -scrollbarRect.y());
-    IntRect transformedClip = clip;
+    LayoutRect transformedClip = clip;
     transformedClip.moveBy(scrollbarRect.location());
     scrollbar->paint(&context, transformedClip);
@@ -1537 +1537 @@
 }
 
-void RenderLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase, const IntRect& clip)
+void RenderLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase, const LayoutRect& clip)
 {
     if (graphicsLayer == layerForHorizontalScrollbar())
@@ -1544 +1544 @@
         paintScrollbar(m_renderView->frameView()->verticalScrollbar(), context, clip);
     else if (graphicsLayer == layerForScrollCorner()) {
-        const IntRect& scrollCorner = m_renderView->frameView()->scrollCornerRect();
+        const LayoutRect& scrollCorner = m_renderView->frameView()->scrollCornerRect();
         context.save();
         context.translate(-scrollCorner.x(), -scrollCorner.y());
-        IntRect transformedClip = clip;
+        LayoutRect transformedClip = clip;
         transformedClip.moveBy(scrollCorner.location());
         m_renderView->frameView()->paintScrollCorner(&context, transformedClip);
@@ -1738 +1738 @@
         m_layerForHorizontalScrollbar = nullptr;
         if (Scrollbar* horizontalScrollbar = m_renderView->frameView()->verticalScrollbar())
-            m_renderView->frameView()->invalidateScrollbar(horizontalScrollbar, IntRect(IntPoint(0, 0), horizontalScrollbar->frameRect().size()));
+            m_renderView->frameView()->invalidateScrollbar(horizontalScrollbar, LayoutRect(LayoutPoint(0, 0), horizontalScrollbar->frameRect().size()));
     }
 
@@ -1745 +1745 @@
         m_layerForVerticalScrollbar = nullptr;
         if (Scrollbar* verticalScrollbar = m_renderView->frameView()->verticalScrollbar())
-            m_renderView->frameView()->invalidateScrollbar(verticalScrollbar, IntRect(IntPoint(0, 0), verticalScrollbar->frameRect().size()));
+            m_renderView->frameView()->invalidateScrollbar(verticalScrollbar, LayoutRect(LayoutPoint(0, 0), verticalScrollbar->frameRect().size()));
     }
 

trunk/Source/WebCore/rendering/RenderLayerCompositor.h

@@ -120 +120 @@
     // Return the bounding box required for compositing layer and its childern, relative to ancestorLayer.
     // If layerBoundingBox is not 0, on return it contains the bounding box of this layer only.
-    IntRect calculateCompositedBounds(const RenderLayer* layer, const RenderLayer* ancestorLayer);
+    LayoutRect calculateCompositedBounds(const RenderLayer*, const RenderLayer* ancestorLayer);
 
     // Repaint the appropriate layers when the given RenderLayer starts or stops being composited.
@@ -133 +133 @@
 
     // Repaint parts of all composited layers that intersect the given absolute rectangle.
-    void repaintCompositedLayersAbsoluteRect(const IntRect&);
+    void repaintCompositedLayersAbsoluteRect(const LayoutRect&);
 
     RenderLayer* rootRenderLayer() const;
@@ -176 +176 @@
 
     // Update the geometry of the layers used for clipping and scrolling in frames.
-    void frameViewDidChangeLocation(const IntPoint& contentsOffset);
+    void frameViewDidChangeLocation(const LayoutPoint& contentsOffset);
     void frameViewDidChangeSize();
-    void frameViewDidScroll(const IntPoint& = IntPoint());
+    void frameViewDidScroll(const LayoutPoint& = LayoutPoint());
 
     String layerTreeAsText(bool showDebugInfo = false);
@@ -203 +203 @@
     virtual void notifyAnimationStarted(const GraphicsLayer*, double) { }
     virtual void notifySyncRequired(const GraphicsLayer*) { scheduleLayerFlush(); }
-    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect&);
+    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const LayoutRect&);
 
     // These calls return false always. They are saying that the layers associated with this client
@@ -223 +223 @@
 
     // Repaint the given rect (which is layer's coords), and regions of child layers that intersect that rect.
-    void recursiveRepaintLayerRect(RenderLayer* layer, const IntRect& rect);
-
-    typedef HashMap<RenderLayer*, IntRect> OverlapMap;
-    void addToOverlapMap(OverlapMap&, RenderLayer*, IntRect& layerBounds, bool& boundsComputed);
+    void recursiveRepaintLayerRect(RenderLayer*, const LayoutRect&);
+
+    typedef HashMap<RenderLayer*, LayoutRect> OverlapMap;
+    void addToOverlapMap(OverlapMap&, RenderLayer*, LayoutRect& layerBounds, bool& boundsComputed);
     void addToOverlapMapRecursive(OverlapMap&, RenderLayer*);
-    static bool overlapsCompositedLayers(OverlapMap&, const IntRect& layerBounds);
+    static bool overlapsCompositedLayers(OverlapMap&, const LayoutRect& layerBounds);
 
     void updateCompositingLayersTimerFired(Timer<RenderLayerCompositor>*);