Revert the merge. Mac build is mysteriously broken.

third_party/WebKit/WebCore/rendering/RenderLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 108 matching lines @@
 }
 
 void ClipRects::destroy(RenderArena* renderArena)
 {
     delete this;
     
     // Recover the size left there for us by operator delete and free the memory.
     renderArena->free(*(size_t *)this, this);
 }
 
-RenderLayer::RenderLayer(RenderBoxModelObject* renderer)
+RenderLayer::RenderLayer(RenderBox* renderer)
     : m_renderer(renderer)
     , m_parent(0)
     , m_previous(0)
     , m_next(0)
     , m_first(0)
     , m_last(0)
     , m_relX(0)
     , m_relY(0)
     , m_x(0)
     , m_y(0)
@@ skipping 81 matching lines @@
 }
 
 #if USE(ACCELERATED_COMPOSITING)
 RenderLayerCompositor* RenderLayer::compositor() const
 {
     ASSERT(renderer()->view());
     return renderer()->view()->compositor();
 }
 #endif // USE(ACCELERATED_COMPOSITING)
 
-void RenderLayer::setStaticY(int staticY)
-{
-    if (m_staticY == staticY)
-        return;
-    m_staticY = staticY;
-    renderer()->setChildNeedsLayout(true, false);
-}
-
 void RenderLayer::updateLayerPositions(bool doFullRepaint, bool checkForRepaint)
 {
     if (doFullRepaint) {
         renderer()->repaint();
 #if USE(ACCELERATED_COMPOSITING)
         checkForRepaint = false;
         // We need the full repaint to propagate to child layers if we are hardware compositing.
         if (!compositor()->inCompositingMode())
             doFullRepaint = false;
 #else
@@ skipping 14 matching lines @@
 
     updateTransform();
      
     if (m_hasVisibleContent) {
         RenderView* view = renderer()->view();
         ASSERT(view);
         // FIXME: Optimize using LayoutState and remove the disableLayoutState() call
         // from updateScrollInfoAfterLayout().
         ASSERT(!view->layoutStateEnabled());
 
-        RenderBoxModelObject* repaintContainer = renderer()->containerForRepaint();
+        RenderBox* repaintContainer = renderer()->containerForRepaint();
         IntRect newRect = renderer()->clippedOverflowRectForRepaint(repaintContainer);
         IntRect newOutlineBox = renderer()->outlineBoundsForRepaint(repaintContainer);
         if (checkForRepaint) {
             if (view && !view->printing()) {
                 if (m_needsFullRepaint) {
                     renderer()->repaintUsingContainer(repaintContainer, m_repaintRect);
                     if (newRect != m_repaintRect)
                         renderer()->repaintUsingContainer(repaintContainer, newRect);
                 } else
                     renderer()->repaintAfterLayoutIfNeeded(repaintContainer, m_repaintRect, m_outlineBox);
@@ skipping 33 matching lines @@
     bool hasTransform = renderer()->hasTransform();
     bool hadTransform = m_transform;
     if (hasTransform != hadTransform) {
         if (hasTransform)
             m_transform.set(new TransformationMatrix);
         else
             m_transform.clear();
     }
     
     if (hasTransform) {
-        RenderBox* box = renderBox();
-        ASSERT(box);
         m_transform->reset();
-        box->style()->applyTransform(*m_transform, box->borderBoxRect().size());
+        renderer()->style()->applyTransform(*m_transform, renderer()->borderBoxRect().size());
     }
 }
 
 void RenderLayer::setHasVisibleContent(bool b)
 { 
     if (m_hasVisibleContent == b && !m_visibleContentStatusDirty)
         return;
     m_visibleContentStatusDirty = false; 
     m_hasVisibleContent = b;
     if (m_hasVisibleContent) {
-        RenderBoxModelObject* repaintContainer = renderer()->containerForRepaint();
+        RenderBox* repaintContainer = renderer()->containerForRepaint();
         m_repaintRect = renderer()->clippedOverflowRectForRepaint(repaintContainer);
         m_outlineBox = renderer()->outlineBoundsForRepaint(repaintContainer);
         if (!isOverflowOnly())
             dirtyStackingContextZOrderLists();
     }
     if (parent())
         parent()->childVisibilityChanged(m_hasVisibleContent);
 }
 
 void RenderLayer::dirtyVisibleContentStatus() 
@@ skipping 69 matching lines @@
         }    
         m_visibleContentStatusDirty = false; 
     }
 }
 
 void RenderLayer::updateLayerPosition()
 {
     // Clear our cached clip rect information.
     clearClipRects();
 
-    RenderBox* rendererBox = renderBox();
-    
-    int x = rendererBox ? rendererBox->x() : 0;
-    int y = rendererBox ? rendererBox->y() : 0;
+    int x = renderer()->x();
+    int y = renderer()->y();
 
     if (!renderer()->isPositioned() && renderer()->parent()) {
         // We must adjust our position by walking up the render tree looking for the
         // nearest enclosing object with a layer.
-        RenderObject* curr = renderer()->parent();
+        RenderBox* curr = renderer()->parentBox();
         while (curr && !curr->hasLayer()) {
-            if (curr->isBox() && !curr->isTableRow()) {
+            if (!curr->isTableRow()) {
                 // Rows and cells share the same coordinate space (that of the section).
                 // Omit them when computing our xpos/ypos.
-                RenderBox* currBox = toRenderBox(curr);
-                x += currBox->x();
-                y += currBox->y();
+                x += curr->x();
+                y += curr->y();
             }
-            curr = curr->parent();
+            curr = curr->parentBox();
         }
-        if (curr->isBox() && curr->isTableRow()) {
+        if (curr->isTableRow()) {
             // Put ourselves into the row coordinate space.
-            RenderBox* currBox = toRenderBox(curr);
-            x -= currBox->x();
-            y -= currBox->y();
+            x -= curr->x();
+            y -= curr->y();
         }
     }
 
     m_relX = m_relY = 0;
     if (renderer()->isRelPositioned()) {
         m_relX = renderer()->relativePositionOffsetX();
         m_relY = renderer()->relativePositionOffsetY();
         x += m_relX; y += m_relY;
     }
     
     // Subtract our parent's scroll offset.
     if (renderer()->isPositioned() && enclosingPositionedAncestor()) {
         RenderLayer* positionedParent = enclosingPositionedAncestor();
 
         // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.
         positionedParent->subtractScrolledContentOffset(x, y);
         
         if (renderer()->isPositioned() && positionedParent->renderer()->isRelPositioned() && positionedParent->renderer()->isRenderInline()) {
-            IntSize offset = toRenderInline(positionedParent->renderer())->relativePositionedInlineOffset(toRenderBox(renderer()));
+            IntSize offset = toRenderInline(positionedParent->renderer())->relativePositionedInlineOffset(renderer());
             x += offset.width();
             y += offset.height();
         }
     } else if (parent())
         parent()->subtractScrolledContentOffset(x, y);
     
     // FIXME: We'd really like to just get rid of the concept of a layer rectangle and rely on the renderers.
 
     setPos(x, y);
 
     if (renderer()->isRenderInline()) {
         RenderInline* inlineFlow = toRenderInline(renderer());
         IntRect lineBox = inlineFlow->linesBoundingBox();
         setWidth(lineBox.width());
         setHeight(lineBox.height());
-    } else if (RenderBox* box = renderBox()) {
-        setWidth(box->width());
-        setHeight(box->height());
+    } else {
+        setWidth(renderer()->width());
+        setHeight(renderer()->height());
 
-        if (!box->hasOverflowClip()) {
-            if (box->overflowWidth() > box->width())
-                setWidth(box->overflowWidth());
-            if (box->overflowHeight() > box->height())
-                setHeight(box->overflowHeight());
+        if (!renderer()->hasOverflowClip()) {
+            if (renderer()->overflowWidth() > renderer()->width())
+                setWidth(renderer()->overflowWidth());
+            if (renderer()->overflowHeight() > renderer()->height())
+                setHeight(renderer()->overflowHeight());
         }
     }
 }
 
 RenderLayer *RenderLayer::stackingContext() const
 {
     RenderLayer* curr = parent();
     for ( ; curr && !curr->renderer()->isRenderView() && !curr->renderer()->isRoot() &&
           curr->renderer()->style()->hasAutoZIndex();
           curr = curr->parent()) { }
@@ skipping 363 matching lines @@
 
 void
 RenderLayer::subtractScrolledContentOffset(int& x, int& y) const
 {
     x -= scrollXOffset() + m_scrollLeftOverflow;
     y -= scrollYOffset();
 }
 
 void RenderLayer::scrollToOffset(int x, int y, bool updateScrollbars, bool repaint)
 {
-    RenderBox* box = renderBox();
-    if (!box)
-        return;
-
-    if (box->style()->overflowX() != OMARQUEE) {
+    if (renderer()->style()->overflowX() != OMARQUEE) {
         if (x < 0) x = 0;
         if (y < 0) y = 0;
     
         // Call the scrollWidth/Height functions so that the dimensions will be computed if they need
         // to be (for overflow:hidden blocks).
-        int maxX = scrollWidth() - box->clientWidth();
-        int maxY = scrollHeight() - box->clientHeight();
+        int maxX = scrollWidth() - renderer()->clientWidth();
+        int maxY = scrollHeight() - renderer()->clientHeight();
         
         if (x > maxX) x = maxX;
         if (y > maxY) y = maxY;
     }
     
     // FIXME: Eventually, we will want to perform a blit.  For now never
     // blit, since the check for blitting is going to be very
     // complicated (since it will involve testing whether our layer
     // is either occluded by another layer or clipped by an enclosing
     // layer or contains fixed backgrounds, etc.).
@@ skipping 38 matching lines @@
     if (updateScrollbars) {
         if (m_hBar)
             m_hBar->setValue(scrollXOffset());
         if (m_vBar)
             m_vBar->setValue(m_scrollY);
     }
 
     // Schedule the scroll DOM event.
     if (view) {
         if (FrameView* frameView = view->frameView())
-            frameView->scheduleEvent(Event::create(eventNames().scrollEvent, false, false), renderer()->element());
+            frameView->scheduleEvent(Event::create(eventNames().scrollEvent, false, false), EventTargetNodeCast(renderer()->element()));
     }
 }
 
 void RenderLayer::scrollRectToVisible(const IntRect &rect, bool scrollToAnchor, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
 {
     RenderLayer* parentLayer = 0;
     IntRect newRect = rect;
     int xOffset = 0, yOffset = 0;
 
     // We may end up propagating a scroll event. It is important that we suspend events until 
     // the end of the function since they could delete the layer or the layer's renderer().
     FrameView* frameView = renderer()->document()->view();
     if (frameView)
         frameView->pauseScheduledEvents();
 
     bool restrictedByLineClamp = false;
     if (renderer()->parent()) {
         parentLayer = renderer()->parent()->enclosingLayer();
         restrictedByLineClamp = renderer()->parent()->style()->lineClamp() >= 0;
     }
 
     if (renderer()->hasOverflowClip() && !restrictedByLineClamp) {
         // Don't scroll to reveal an overflow layer that is restricted by the -webkit-line-clamp property.
         // This will prevent us from revealing text hidden by the slider in Safari RSS.
-        RenderBox* box = renderBox();
-        ASSERT(box);
-        FloatPoint absPos = box->localToAbsolute();
-        absPos.move(box->borderLeft(), box->borderTop());
+        FloatPoint absPos = renderer()->localToAbsolute();
+        absPos.move(renderer()->borderLeft(), renderer()->borderTop());
 
-        IntRect layerBounds = IntRect(absPos.x() + scrollXOffset(), absPos.y() + scrollYOffset(), box->clientWidth(), box->clientHeight());
+        IntRect layerBounds = IntRect(absPos.x() + scrollXOffset(), absPos.y() + scrollYOffset(), renderer()->clientWidth(), renderer()->clientHeight());
         IntRect exposeRect = IntRect(rect.x() + scrollXOffset(), rect.y() + scrollYOffset(), rect.width(), rect.height());
         IntRect r = getRectToExpose(layerBounds, exposeRect, alignX, alignY);
         
         xOffset = r.x() - absPos.x();
         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));
         
         if (xOffset != scrollXOffset() || yOffset != scrollYOffset()) {
             int diffX = scrollXOffset();
             int diffY = scrollYOffset();
             scrollToOffset(xOffset, yOffset);
             diffX = scrollXOffset() - diffX;
             diffY = scrollYOffset() - diffY;
             newRect.setX(rect.x() - diffX);
             newRect.setY(rect.y() - diffY);
         }
-    } else if (!parentLayer && renderer()->isBox() && renderBox()->canBeProgramaticallyScrolled(scrollToAnchor)) {
+    } else if (!parentLayer && renderer()->canBeProgramaticallyScrolled(scrollToAnchor)) {
         if (frameView) {
             if (renderer()->document() && renderer()->document()->ownerElement() && renderer()->document()->ownerElement()->renderer()) {
                 IntRect viewRect = frameView->visibleContentRect();
                 IntRect r = getRectToExpose(viewRect, rect, alignX, alignY);
                 
                 xOffset = r.x();
                 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));
@@ skipping 239 matching lines @@
     bool hasHorizontalBar = layer->horizontalScrollbar();
     bool hasVerticalBar = layer->verticalScrollbar();
     bool hasResizer = layer->renderer()->style()->resize() != RESIZE_NONE;
     if ((hasHorizontalBar && hasVerticalBar) || (hasResizer && (hasHorizontalBar || hasVerticalBar)))
         return cornerRect(layer, bounds);
     return IntRect();
 }
 
 static IntRect resizerCornerRect(const RenderLayer* layer, const IntRect& bounds)
 {
-    ASSERT(layer->renderer()->isBox());
     if (layer->renderer()->style()->resize() == RESIZE_NONE)
         return IntRect();
     return cornerRect(layer, bounds);
 }
 
 bool RenderLayer::scrollbarCornerPresent() const
 {
-    ASSERT(renderer()->isBox());
-    return !scrollCornerRect(this, renderBox()->borderBoxRect()).isEmpty();
+    return !scrollCornerRect(this, renderer()->borderBoxRect()).isEmpty();
 }
 
 void RenderLayer::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
 {
     IntRect scrollRect = rect;
-    RenderBox* box = renderBox();
-    ASSERT(box);
     if (scrollbar == m_vBar.get())
-        scrollRect.move(box->width() - box->borderRight() - box->width(), box->borderTop());
+        scrollRect.move(renderer()->width() - renderer()->borderRight() - scrollbar->width(), renderer()->borderTop());
     else
-        scrollRect.move(box->borderLeft(), box->height() - box->borderBottom() - scrollbar->height());
+        scrollRect.move(renderer()->borderLeft(), renderer()->height() - renderer()->borderBottom() - scrollbar->height());
     renderer()->repaintRectangle(scrollRect);
 }
 
 PassRefPtr<Scrollbar> RenderLayer::createScrollbar(ScrollbarOrientation orientation)
 {
     RefPtr<Scrollbar> widget;
     bool hasCustomScrollbarStyle = renderer()->node()->shadowAncestorNode()->renderer()->style()->hasPseudoStyle(SCROLLBAR);
     if (hasCustomScrollbarStyle)
         widget = RenderScrollbar::createCustomScrollbar(this, orientation, renderer()->node()->shadowAncestorNode()->renderBox());
     else
@@ skipping 78 matching lines @@
     IntPoint bottomRight(width(), height());
     IntPoint localPoint = absoluteToContents(absolutePoint);
     return localPoint - bottomRight;
 }
 
 void RenderLayer::positionOverflowControls(int tx, int ty)
 {
     if (!m_hBar && !m_vBar && (!renderer()->hasOverflowClip() || renderer()->style()->resize() == RESIZE_NONE))
         return;
     
-    RenderBox* box = renderBox();
-    if (!box)
-        return;
-
-    IntRect borderBox = box->borderBoxRect();
+    IntRect borderBox = renderer()->borderBoxRect();
     IntRect scrollCorner(scrollCornerRect(this, borderBox));
     IntRect absBounds(borderBox.x() + tx, borderBox.y() + ty, borderBox.width(), borderBox.height());
     if (m_vBar)
-        m_vBar->setFrameRect(IntRect(absBounds.right() - box->borderRight() - m_vBar->width(),
-                                     absBounds.y() + box->borderTop(),
+        m_vBar->setFrameRect(IntRect(absBounds.right() - renderer()->borderRight() - m_vBar->width(),
+                                     absBounds.y() + renderer()->borderTop(),
                                      m_vBar->width(),
-                                     absBounds.height() - (box->borderTop() + box->borderBottom()) - scrollCorner.height()));
+                                     absBounds.height() - (renderer()->borderTop() + renderer()->borderBottom()) - scrollCorner.height()));
 
     if (m_hBar)
-        m_hBar->setFrameRect(IntRect(absBounds.x() + box->borderLeft(),
-                                     absBounds.bottom() - box->borderBottom() - m_hBar->height(),
-                                     absBounds.width() - (box->borderLeft() + box->borderRight()) - scrollCorner.width(),
+        m_hBar->setFrameRect(IntRect(absBounds.x() + renderer()->borderLeft(),
+                                     absBounds.bottom() - renderer()->borderBottom() - m_hBar->height(),
+                                     absBounds.width() - (renderer()->borderLeft() + renderer()->borderRight()) - scrollCorner.width(),
                                      m_hBar->height()));
     
     if (m_scrollCorner)
         m_scrollCorner->setFrameRect(scrollCorner);
     if (m_resizer)
         m_resizer->setFrameRect(resizerCornerRect(this, borderBox));
 }
 
 int RenderLayer::scrollWidth()
 {
     if (m_scrollDimensionsDirty)
         computeScrollDimensions();
     return m_scrollWidth;
 }
 
 int RenderLayer::scrollHeight()
 {
     if (m_scrollDimensionsDirty)
         computeScrollDimensions();
     return m_scrollHeight;
 }
 
 void RenderLayer::computeScrollDimensions(bool* needHBar, bool* needVBar)
 {
-    RenderBox* box = renderBox();
-    ASSERT(box);
-    
     m_scrollDimensionsDirty = false;
     
     bool ltr = renderer()->style()->direction() == LTR;
 
-    int clientWidth = box->clientWidth();
-    int clientHeight = box->clientHeight();
+    int clientWidth = renderer()->clientWidth();
+    int clientHeight = renderer()->clientHeight();
 
-    m_scrollLeftOverflow = ltr ? 0 : min(0, box->leftmostPosition(true, false) - box->borderLeft());
+    m_scrollLeftOverflow = ltr ? 0 : min(0, renderer()->leftmostPosition(true, false) - renderer()->borderLeft());
 
     int rightPos = ltr ?
-                    box->rightmostPosition(true, false) - box->borderLeft() :
+                    renderer()->rightmostPosition(true, false) - renderer()->borderLeft() :
                     clientWidth - m_scrollLeftOverflow;
-    int bottomPos = renderer()->lowestPosition(true, false) - box->borderTop();
+    int bottomPos = renderer()->lowestPosition(true, false) - renderer()->borderTop();
 
     m_scrollWidth = max(rightPos, clientWidth);
     m_scrollHeight = max(bottomPos, clientHeight);
     
     m_scrollOriginX = ltr ? 0 : m_scrollWidth - clientWidth;
 
     if (needHBar)
         *needHBar = rightPos > clientWidth;
     if (needVBar)
         *needVBar = bottomPos > clientHeight;
@@ skipping 11 matching lines @@
     
     bool horizontalOverflowChanged = (m_horizontalOverflow != horizontalOverflow);
     bool verticalOverflowChanged = (m_verticalOverflow != verticalOverflow);
     
     if (horizontalOverflowChanged || verticalOverflowChanged) {
         m_horizontalOverflow = horizontalOverflow;
         m_verticalOverflow = verticalOverflow;
         
         if (FrameView* frameView = renderer()->document()->view()) {
             frameView->scheduleEvent(OverflowEvent::create(horizontalOverflowChanged, horizontalOverflow, verticalOverflowChanged, verticalOverflow),
-                renderer()->element());
+                EventTargetNodeCast(renderer()->element()));
         }
     }
 }
 
 void
 RenderLayer::updateScrollInfoAfterLayout()
 {
-    RenderBox* box = renderBox();
-    if (!box)
-        return;
-
     m_scrollDimensionsDirty = true;
 
     bool horizontalOverflow, verticalOverflow;
     computeScrollDimensions(&horizontalOverflow, &verticalOverflow);
 
-    if (box->style()->overflowX() != OMARQUEE) {
+    if (renderer()->style()->overflowX() != OMARQUEE) {
         // 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(m_scrollY, scrollHeight() - box->clientHeight()));
+        int newX = max(0, min(scrollXOffset(), scrollWidth() - renderer()->clientWidth()));
+        int newY = max(0, min(m_scrollY, scrollHeight() - renderer()->clientHeight()));
         if (newX != scrollXOffset() || newY != m_scrollY) {
             RenderView* view = renderer()->view();
             ASSERT(view);
             // scrollToOffset() may call updateLayerPositions(), which doesn't work
             // with LayoutState.
             // FIXME: Remove the disableLayoutState/enableLayoutState if the above changes.
             if (view)
                 view->disableLayoutState();
             scrollToOffset(newX, newY);
             if (view)
@@ skipping 11 matching lines @@
         m_vBar->setEnabled(verticalOverflow);
 
     // A dynamic change from a scrolling overflow to overflow:hidden means we need to get rid of any
     // scrollbars that may be present.
     if (renderer()->style()->overflowX() == OHIDDEN && haveHorizontalBar)
         setHasHorizontalScrollbar(false);
     if (renderer()->style()->overflowY() == OHIDDEN && haveVerticalBar)
         setHasVerticalScrollbar(false);
     
     // overflow:auto may need to lay out again if scrollbars got added/removed.
-    bool scrollbarsChanged = (box->hasAutoHorizontalScrollbar() && haveHorizontalBar != horizontalOverflow) || 
-                             (box->hasAutoVerticalScrollbar() && haveVerticalBar != verticalOverflow);    
+    bool scrollbarsChanged = (renderer()->hasAutoHorizontalScrollbar() && haveHorizontalBar != horizontalOverflow) || 
+                             (renderer()->hasAutoVerticalScrollbar() && haveVerticalBar != verticalOverflow);    
     if (scrollbarsChanged) {
-        if (box->hasAutoHorizontalScrollbar())
+        if (renderer()->hasAutoHorizontalScrollbar())
             setHasHorizontalScrollbar(horizontalOverflow);
-        if (box->hasAutoVerticalScrollbar())
+        if (renderer()->hasAutoVerticalScrollbar())
             setHasVerticalScrollbar(verticalOverflow);
 
 #if ENABLE(DASHBOARD_SUPPORT)
         // Force an update since we know the scrollbars have changed things.
         if (renderer()->document()->hasDashboardRegions())
             renderer()->document()->setDashboardRegionsDirty(true);
 #endif
 
         renderer()->repaint();
 
         if (renderer()->style()->overflowX() == OAUTO || renderer()->style()->overflowY() == OAUTO) {
             if (!m_inOverflowRelayout) {
                 // Our proprietary overflow: overlay value doesn't trigger a layout.
                 m_inOverflowRelayout = true;
                 renderer()->setNeedsLayout(true, false);
                 if (renderer()->isRenderBlock())
                     toRenderBlock(renderer())->layoutBlock(true);
                 else
                     renderer()->layout();
                 m_inOverflowRelayout = false;
             }
         }
     }
     
     // If overflow:scroll is turned into overflow:auto a bar might still be disabled (Bug 11985).
-    if (m_hBar && box->hasAutoHorizontalScrollbar())
+    if (m_hBar && renderer()->hasAutoHorizontalScrollbar())
         m_hBar->setEnabled(true);
-    if (m_vBar && box->hasAutoVerticalScrollbar())
+    if (m_vBar && renderer()->hasAutoVerticalScrollbar())
         m_vBar->setEnabled(true);
 
     // Set up the range (and page step/line step).
     if (m_hBar) {
-        int clientWidth = box->clientWidth();
+        int clientWidth = renderer()->clientWidth();
         int pageStep = (clientWidth - cAmountToKeepWhenPaging);
         if (pageStep < 0) pageStep = clientWidth;
         m_hBar->setSteps(cScrollbarPixelsPerLineStep, pageStep);
         m_hBar->setProportion(clientWidth, m_scrollWidth);
         m_hBar->setValue(scrollXOffset());
     }
     if (m_vBar) {
-        int clientHeight = box->clientHeight();
+        int clientHeight = renderer()->clientHeight();
         int pageStep = (clientHeight - cAmountToKeepWhenPaging);
         if (pageStep < 0) pageStep = clientHeight;
         m_vBar->setSteps(cScrollbarPixelsPerLineStep, pageStep);
         m_vBar->setProportion(clientHeight, m_scrollHeight);
     }
  
     if (renderer()->element() && renderer()->document()->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))
         updateOverflowStatus(horizontalOverflow, verticalOverflow);
 }
 
@@ skipping 17 matching lines @@
     // We fill our scroll corner with white if we have a scrollbar that doesn't run all the way up to the
     // edge of the box.
     paintScrollCorner(context, tx, ty, damageRect);
     
     // Paint our resizer last, since it sits on top of the scroll corner.
     paintResizer(context, tx, ty, damageRect);
 }
 
 void RenderLayer::paintScrollCorner(GraphicsContext* context, int tx, int ty, const IntRect& damageRect)
 {
-    RenderBox* box = renderBox();
-    ASSERT(box);
-
-    IntRect cornerRect = scrollCornerRect(this, box->borderBoxRect());
+    IntRect cornerRect = scrollCornerRect(this, renderer()->borderBoxRect());
     IntRect absRect = IntRect(cornerRect.x() + tx, cornerRect.y() + ty, cornerRect.width(), cornerRect.height());
     if (!absRect.intersects(damageRect))
         return;
 
     if (context->updatingControlTints()) {
         updateScrollCornerStyle();
         return;
     }
 
     if (m_scrollCorner) {
         m_scrollCorner->paintIntoRect(context, tx, ty, absRect);
         return;
     }
     
     context->fillRect(absRect, Color::white);
 }
 
 void RenderLayer::paintResizer(GraphicsContext* context, int tx, int ty, const IntRect& damageRect)
 {
     if (renderer()->style()->resize() == RESIZE_NONE)
         return;
 
-    RenderBox* box = renderBox();
-    ASSERT(box);
-
-    IntRect cornerRect = resizerCornerRect(this, box->borderBoxRect());
+    IntRect cornerRect = resizerCornerRect(this, renderer()->borderBoxRect());
     IntRect absRect = IntRect(cornerRect.x() + tx, cornerRect.y() + ty, cornerRect.width(), cornerRect.height());
     if (!absRect.intersects(damageRect))
         return;
 
     if (context->updatingControlTints()) {
         updateResizerStyle();
         return;
     }
     
     if (m_resizer) {
@@ skipping 18 matching lines @@
         context->drawRect(largerCorner);
         context->restore();
     }
 }
 
 bool RenderLayer::isPointInResizeControl(const IntPoint& absolutePoint) const
 {
     if (!renderer()->hasOverflowClip() || renderer()->style()->resize() == RESIZE_NONE)
         return false;
     
-    RenderBox* box = renderBox();
-    ASSERT(box);
-
     IntPoint localPoint = absoluteToContents(absolutePoint);
 
-    IntRect localBounds(0, 0, box->width(), box->height());
+    IntRect localBounds(0, 0, renderer()->width(), renderer()->height());
     return resizerCornerRect(this, localBounds).contains(localPoint);
 }
     
 bool RenderLayer::hitTestOverflowControls(HitTestResult& result)
 {
     if (!m_hBar && !m_vBar && (!renderer()->hasOverflowClip() || renderer()->style()->resize() == RESIZE_NONE))
         return false;
 
-    RenderBox* box = renderBox();
-    ASSERT(box);
-
     int x = 0;
     int y = 0;
     convertToLayerCoords(root(), x, y);
-    IntRect absBounds(x, y, box->width(), box->height());
+    IntRect absBounds(x, y, renderer()->width(), renderer()->height());
     
     IntRect resizeControlRect;
     if (renderer()->style()->resize() != RESIZE_NONE) {
         resizeControlRect = resizerCornerRect(this, absBounds);
         if (resizeControlRect.contains(result.point()))
             return true;
     }
 
     int resizeControlSize = max(resizeControlRect.height(), 0);
 
     if (m_vBar) {
-        IntRect vBarRect(absBounds.right() - box->borderRight() - m_vBar->width(), 
-                         absBounds.y() + box->borderTop(),
-                         m_vBar->width(),
-                         absBounds.height() - (box->borderTop() + box->borderBottom()) - (m_hBar ? m_hBar->height() : resizeControlSize));
+        IntRect vBarRect(absBounds.right() - renderer()->borderRight() - m_vBar->width(), absBounds.y() + renderer()->borderTop(), m_vBar->width(), absBounds.height() - (renderer()->borderTop() + renderer()->borderBottom()) - (m_hBar ? m_hBar->height() : resizeControlSize));
         if (vBarRect.contains(result.point())) {
             result.setScrollbar(m_vBar.get());
             return true;
         }
     }
 
     resizeControlSize = max(resizeControlRect.width(), 0);
     if (m_hBar) {
-        IntRect hBarRect(absBounds.x() + box->borderLeft(),
-                         absBounds.bottom() - box->borderBottom() - m_hBar->height(),
-                         absBounds.width() - (box->borderLeft() + box->borderRight()) - (m_vBar ? m_vBar->width() : resizeControlSize),
-                         m_hBar->height());
+        IntRect hBarRect(absBounds.x() + renderer()->borderLeft(), absBounds.bottom() - renderer()->borderBottom() - m_hBar->height(), absBounds.width() - (renderer()->borderLeft() + renderer()->borderRight()) - (m_vBar ? m_vBar->width() : resizeControlSize), m_hBar->height());
         if (hBarRect.contains(result.point())) {
             result.setScrollbar(m_hBar.get());
             return true;
         }
     }
 
     return false;
 }
 
 bool RenderLayer::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)
@@ skipping 119 matching lines @@
         m_paintingInsideReflection = true;
         reflectionLayer()->paintLayer(rootLayer, p, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot, false, temporaryClipRects);
         m_paintingInsideReflection = false;
     }
 
     // Calculate the clip rects we should use.
     IntRect layerBounds, damageRect, clipRectToApply, outlineRect;
     calculateRects(rootLayer, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect, temporaryClipRects);
     int x = layerBounds.x();
     int y = layerBounds.y();
-    int tx = x - renderBoxX();
-    int ty = y - renderBoxY();
+    int tx = x - renderer()->x();
+    int ty = y - renderer()->y();
                              
     // Ensure our lists are up-to-date.
     updateLayerListsIfNeeded();
 
     bool selectionOnly = paintRestriction == PaintRestrictionSelectionOnly || paintRestriction == PaintRestrictionSelectionOnlyBlackText;
     bool forceBlackText = paintRestriction == PaintRestrictionSelectionOnlyBlackText;
     
     // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which
     // is done by passing a nil paintingRoot down to our renderer (as if no paintingRoot was ever set).
     // Else, our renderer tree may or may not contain the painting root, so we pass that root along
@@ skipping 201 matching lines @@
         for (int i = m_overflowList->size() - 1; i >= 0; --i) {
             insideLayer = m_overflowList->at(i)->hitTestLayer(rootLayer, request, result, hitTestRect, hitTestPoint);
             if (insideLayer)
                 return insideLayer;
         }
     }
 
     // Next we want to see if the mouse pos is inside the child RenderObjects of the layer.
     if (fgRect.contains(hitTestPoint) && 
         renderer()->hitTest(request, result, hitTestPoint,
-                            layerBounds.x() - renderBoxX(),
-                            layerBounds.y() - renderBoxY(), 
+                            layerBounds.x() - renderer()->x(),
+                            layerBounds.y() - renderer()->y(), 
                             HitTestDescendants)) {
         // For positioned generated content, we might still not have a
         // node by the time we get to the layer level, since none of
         // the content in the layer has an element. So just walk up
         // the tree.
         if (!result.innerNode() || !result.innerNonSharedNode()) {
             Node* e = enclosingElement();
             if (!result.innerNode())
                 result.setInnerNode(e);
             if (!result.innerNonSharedNode())
                 result.setInnerNonSharedNode(e);
         }
 
         return this;
     }
         
     // Now check our negative z-index children.
     if (m_negZOrderList) {
         for (int i = m_negZOrderList->size() - 1; i >= 0; --i) {
             insideLayer = m_negZOrderList->at(i)->hitTestLayer(rootLayer, request, result, hitTestRect, hitTestPoint);
             if (insideLayer)
                 return insideLayer;
         }
     }
 
     // Next we want to see if the mouse is inside this layer but not any of its children.
     if (bgRect.contains(hitTestPoint) &&
         renderer()->hitTest(request, result, hitTestPoint,
-                            layerBounds.x() - renderBoxX(),
-                            layerBounds.y() - renderBoxY(),
+                            layerBounds.x() - renderer()->x(),
+                            layerBounds.y() - renderer()->y(),
                             HitTestSelf)) {
         if (!result.innerNode() || !result.innerNonSharedNode()) {
             Node* e = enclosingElement();
             if (!result.innerNode())
                 result.setInnerNode(e);
             if (!result.innerNonSharedNode())
                 result.setInnerNonSharedNode(e);
         }
 
         return this;
@@ skipping 217 matching lines @@
         // Go from our first line box to our last line box.
         RenderInline* inlineFlow = toRenderInline(renderer());
         InlineFlowBox* firstBox = inlineFlow->firstLineBox();
         if (!firstBox)
             return result;
         int top = firstBox->root()->topOverflow();
         int bottom = inlineFlow->lastLineBox()->root()->bottomOverflow();
         int left = firstBox->xPos();
         for (InlineRunBox* curr = firstBox->nextLineBox(); curr; curr = curr->nextLineBox())
             left = min(left, curr->xPos());
-        result = IntRect(left, top, width(), bottom - top);
+        result = IntRect(left, (top - renderer()->y()), width(), bottom - top);
     } else if (renderer()->isTableRow()) {
         // Our bounding box is just the union of all of our cells' border/overflow rects.
         for (RenderObject* child = renderer()->firstChild(); child; child = child->nextSibling()) {
             if (child->isTableCell()) {
                 IntRect bbox = toRenderBox(child)->borderBoxRect();
                 result.unite(bbox);
-                IntRect overflowRect = renderBox()->overflowRect(false);
+                IntRect overflowRect = renderer()->overflowRect(false);
                 if (bbox != overflowRect)
                     result.unite(overflowRect);
             }
         }
     } else {
-        RenderBox* box = renderBox();
-        ASSERT(box);
-        if (box->hasMask())
-            result = box->maskClipRect();
+        if (renderer()->hasMask())
+            result = renderer()->maskClipRect();
         else {
-            IntRect bbox = box->borderBoxRect();
+            IntRect bbox = renderer()->borderBoxRect();
             result = bbox;
-            IntRect overflowRect = box->overflowRect(false);
+            IntRect overflowRect = renderer()->overflowRect(false);
             if (bbox != overflowRect)
                 result.unite(overflowRect);
         }
     }
 
     RenderView* view = renderer()->view();
     ASSERT(view);
     if (view)
         result.inflate(view->maximalOutlineSize()); // Used to apply a fudge factor to dirty-rect checks on blocks/tables.
 
@@ skipping 452 matching lines @@
     if (m_marquee)
         m_marquee->suspend();
     
     for (RenderLayer* curr = firstChild(); curr; curr = curr->nextSibling())
         curr->suspendMarquees();
 }
 
 } // namespace WebCore