Revert the merge. Mac build is mysteriously broken.

third_party/WebKit/WebCore/rendering/RenderBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 43 matching lines @@
 using namespace std;
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 // Used by flexible boxes when flexing this element.
 typedef WTF::HashMap<const RenderBox*, int> OverrideSizeMap;
 static OverrideSizeMap* gOverrideSizeMap = 0;
 
+bool RenderBox::s_wasFloating = false;
 bool RenderBox::s_hadOverflowClip = false;
 
 RenderBox::RenderBox(Node* node)
     : RenderBoxModelObject(node)
     , m_marginLeft(0)
     , m_marginRight(0)
     , m_marginTop(0)
     , m_marginBottom(0)
     , m_minPrefWidth(-1)
     , m_maxPrefWidth(-1)
+    , m_layer(0)
     , m_inlineBoxWrapper(0)
 {
     setIsBox();
 }
 
 RenderBox::~RenderBox()
 {
 }
 
 void RenderBox::destroy()
 {
     // A lot of the code in this function is just pasted into
     // RenderWidget::destroy. If anything in this function changes,
     // be sure to fix RenderWidget::destroy() as well.
     if (hasOverrideSize())
         gOverrideSizeMap->remove(this);
 
+    // This must be done before we destroy the RenderObject.
+    if (m_layer)
+        m_layer->clearClipRects();
+
     if (style() && (style()->height().isPercent() || style()->minHeight().isPercent() || style()->maxHeight().isPercent()))
         RenderBlock::removePercentHeightDescendant(this);
 
     RenderBoxModelObject::destroy();
 }
 
 void RenderBox::removeFloatingOrPositionedChildFromBlockLists()
 {
     ASSERT(isFloatingOrPositioned());
 
@@ skipping 15 matching lines @@
         RenderObject* p;
         for (p = parent(); p; p = p->parent()) {
             if (p->isRenderBlock())
                 toRenderBlock(p)->removePositionedObject(this);
         }
     }
 }
 
 void RenderBox::styleWillChange(StyleDifference diff, const RenderStyle* newStyle)
 {
+    s_wasFloating = isFloating();
     s_hadOverflowClip = hasOverflowClip();
 
     if (style()) {
         // If our z-index changes value or our visibility changes,
         // we need to dirty our stacking context's z-order list.
         if (newStyle) {
             if (hasLayer() && (style()->hasAutoZIndex() != newStyle->hasAutoZIndex() ||
                                style()->zIndex() != newStyle->zIndex() ||
                                style()->visibility() != newStyle->visibility())) {
                 layer()->dirtyStackingContextZOrderLists();
@@ skipping 46 matching lines @@
                     removeFloatingOrPositionedChildFromBlockLists();
             }
         }
     }
 
     RenderBoxModelObject::styleWillChange(diff, newStyle);
 }
 
 void RenderBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
+    // We need to ensure that view->maximalOutlineSize() is valid for any repaints that happen
+    // during the style change (it's used by clippedOverflowRectForRepaint()).
+    if (style()->outlineWidth() > 0 && style()->outlineSize() > maximalOutlineSize(PaintPhaseOutline))
+        toRenderView(document()->renderer())->setMaximalOutlineSize(style()->outlineSize());
+
     RenderBoxModelObject::styleDidChange(diff, oldStyle);
 
     if (needsLayout() && oldStyle && (oldStyle->height().isPercent() || oldStyle->minHeight().isPercent() || oldStyle->maxHeight().isPercent()))
         RenderBlock::removePercentHeightDescendant(this);
 
-    // If our zoom factor changes and we have a defined scrollLeft/Top, we need to adjust that value into the
-    // new zoomed coordinate space.
-    if (hasOverflowClip() && oldStyle && style() && oldStyle->effectiveZoom() != style()->effectiveZoom()) {
-        int left = scrollLeft();
-        if (left) {
-            left = (left / oldStyle->effectiveZoom()) * style()->effectiveZoom();
-            setScrollLeft(left);
-        }
-        int top = scrollTop();
-        if (top) {
-            top = (top / oldStyle->effectiveZoom()) * style()->effectiveZoom();
-            setScrollTop(top);
-        }
-    }
-
-    // Set the text color if we're the body.
-    if (isBody())
-        document()->setTextColor(style()->color());
-}
-
-void RenderBox::updateBoxModelInfoFromStyle()
-{
-    RenderBoxModelObject::updateBoxModelInfoFromStyle();
-
     bool isRootObject = isRoot();
     bool isViewObject = isRenderView();
 
     // The root and the RenderView always paint their backgrounds/borders.
     if (isRootObject || isViewObject)
         setHasBoxDecorations(true);
 
-    setPositioned(style()->position() == AbsolutePosition || style()->position() == FixedPosition);
-    setFloating(!isPositioned() && style()->isFloating());
+    setInline(style()->isDisplayInlineType());
+
+    switch (style()->position()) {
+        case AbsolutePosition:
+        case FixedPosition:
+            setPositioned(true);
+            break;
+        default:
+            setPositioned(false);
+
+            if (style()->isFloating())
+                setFloating(true);
+
+            if (style()->position() == RelativePosition)
+                setRelPositioned(true);
+            break;
+    }
 
     // We also handle <body> and <html>, whose overflow applies to the viewport.
     if (style()->overflowX() != OVISIBLE && !isRootObject && (isRenderBlock() || isTableRow() || isTableSection())) {
         bool boxHasOverflowClip = true;
         if (isBody()) {
             // Overflow on the body can propagate to the viewport under the following conditions.
             // (1) The root element is <html>.
             // (2) We are the primary <body> (can be checked by looking at document.body).
             // (3) The root element has visible overflow.
             if (document()->documentElement()->hasTagName(htmlTag) &&
                 document()->body() == element() &&
                 document()->documentElement()->renderer()->style()->overflowX() == OVISIBLE)
                 boxHasOverflowClip = false;
         }
         
         // Check for overflow clip.
         // It's sufficient to just check one direction, since it's illegal to have visible on only one overflow value.
         if (boxHasOverflowClip) {
             if (!s_hadOverflowClip)
                 // Erase the overflow
                 repaint();
             setHasOverflowClip();
         }
     }
 
-    setHasTransform(style()->hasTransform());
+    // FIXME: we should make transforms really work on inline flows eventually.
+    if (!isInline() || isReplaced())
+        setHasTransform(style()->hasTransform());
     setHasReflection(style()->boxReflect());
+
+    if (requiresLayer()) {
+        if (!m_layer) {
+            if (s_wasFloating && isFloating())
+                setChildNeedsLayout(true);
+            m_layer = new (renderArena()) RenderLayer(this);
+            setHasLayer(true);
+            m_layer->insertOnlyThisLayer();
+            if (parent() && !needsLayout() && containingBlock())
+                m_layer->updateLayerPositions();
+        }
+    } else if (m_layer && !isRootObject && !isViewObject) {
+        ASSERT(m_layer->parent());
+        RenderLayer* layer = m_layer;
+        m_layer = 0;
+        setHasLayer(false);
+        setHasTransform(false); // Either a transform wasn't specified or the object doesn't support transforms, so just null out the bit.
+        setHasReflection(false);
+        layer->removeOnlyThisLayer();
+        if (s_wasFloating && isFloating())
+            setChildNeedsLayout(true);
+    }
+
+    // If our zoom factor changes and we have a defined scrollLeft/Top, we need to adjust that value into the
+    // new zoomed coordinate space.
+    if (hasOverflowClip() && oldStyle && style() && oldStyle->effectiveZoom() != style()->effectiveZoom()) {
+        int left = scrollLeft();
+        if (left) {
+            left = (left / oldStyle->effectiveZoom()) * style()->effectiveZoom();
+            setScrollLeft(left);
+        }
+        int top = scrollTop();
+        if (top) {
+            top = (top / oldStyle->effectiveZoom()) * style()->effectiveZoom();
+            setScrollTop(top);
+        }
+    }
+
+    if (m_layer)
+        m_layer->styleChanged(diff, oldStyle);
+
+    // Set the text color if we're the body.
+    if (isBody())
+        document()->setTextColor(style()->color());
 }
 
 void RenderBox::layout()
 {
     ASSERT(needsLayout());
 
     RenderObject* child = firstChild();
     if (!child) {
         setNeedsLayout(false);
         return;
@@ skipping 101 matching lines @@
     return height() - borderTop() - borderBottom() - horizontalScrollbarHeight();
 }
 
 // scrollWidth/scrollHeight will be the same as overflowWidth/overflowHeight unless the
 // object has overflow:hidden/scroll/auto specified and also has overflow.
 // FIXME: It's not completely clear how scrollWidth/Height should behave for 
 // objects with visible overflow.
 int RenderBox::scrollWidth() const
 {
     if (hasOverflowClip())
-        return layer()->scrollWidth();
+        return m_layer->scrollWidth();
     return overflowWidth();
 }
 
 int RenderBox::scrollHeight() const
 {
     if (hasOverflowClip())
-        return layer()->scrollHeight();
+        return m_layer->scrollHeight();
     return overflowHeight();
 }
 
 int RenderBox::scrollLeft() const
 {
-    return hasOverflowClip() ? layer()->scrollXOffset() : 0;
+    return hasOverflowClip() ? m_layer->scrollXOffset() : 0;
 }
 
 int RenderBox::scrollTop() const
 {
-    return hasOverflowClip() ? layer()->scrollYOffset() : 0;
+    return hasOverflowClip() ? m_layer->scrollYOffset() : 0;
 }
 
 void RenderBox::setScrollLeft(int newLeft)
 {
     if (hasOverflowClip())
-        layer()->scrollToXOffset(newLeft);
+        m_layer->scrollToXOffset(newLeft);
 }
 
 void RenderBox::setScrollTop(int newTop)
 {
     if (hasOverflowClip())
-        layer()->scrollToYOffset(newTop);
+        m_layer->scrollToYOffset(newTop);
 }
 
 int RenderBox::paddingTop(bool) const
 {
     int w = 0;
     Length padding = style()->paddingTop();
     if (padding.isPercent())
         w = containingBlock()->availableWidth();
     return padding.calcMinValue(w);
 }
@@ skipping 43 matching lines @@
     return rect;
 }
 
 FloatQuad RenderBox::absoluteContentQuad() const
 {
     IntRect rect = contentBoxRect();
     return localToAbsoluteQuad(FloatRect(rect));
 }
 
 
-IntRect RenderBox::outlineBoundsForRepaint(RenderBoxModelObject* /*repaintContainer*/) const
+IntRect RenderBox::outlineBoundsForRepaint(RenderBox* /*repaintContainer*/) const
 {
     IntRect box = borderBoundingBox();
     adjustRectForOutlineAndShadow(box);
 
     FloatQuad absOutlineQuad = localToAbsoluteQuad(FloatRect(box));
     box = absOutlineQuad.enclosingBoundingBox();
 
     // FIXME: layoutDelta needs to be applied in parts before/after transforms and
     // repaint containers. https://bugs.webkit.org/show_bug.cgi?id=23308
     box.move(view()->layoutDelta());
@@ skipping 782 matching lines @@
 
     int bLeft = borderLeft();
     int bTop = borderTop();
 
     int clipX = tx + bLeft;
     int clipY = ty + bTop;
     int clipWidth = width() - bLeft - borderRight();
     int clipHeight = height() - bTop - borderBottom();
 
     // Subtract out scrollbars if we have them.
-    if (layer()) {
-        clipWidth -= layer()->verticalScrollbarWidth();
-        clipHeight -= layer()->horizontalScrollbarHeight();
+    if (m_layer) {
+        clipWidth -= m_layer->verticalScrollbarWidth();
+        clipHeight -= m_layer->horizontalScrollbarHeight();
     }
 
     return IntRect(clipX, clipY, clipWidth, clipHeight);
 }
 
 IntRect RenderBox::getClipRect(int tx, int ty)
 {
     int clipX = tx;
     int clipY = ty;
     int clipWidth = width();
@@ skipping 31 matching lines @@
 }
 
 FloatPoint RenderBox::localToAbsolute(FloatPoint localPoint, bool fixed, bool useTransforms) const
 {
     if (RenderView* v = view()) {
         if (v->layoutStateEnabled()) {
             LayoutState* layoutState = v->layoutState();
             IntSize offset = layoutState->m_offset;
             offset.expand(x(), y());
             localPoint += offset;
-            if (style()->position() == RelativePosition && layer())
-                localPoint += layer()->relativePositionOffset();
+            if (style()->position() == RelativePosition && m_layer)
+                localPoint += m_layer->relativePositionOffset();
             return localPoint;
         }
     }
 
     if (style()->position() == FixedPosition)
         fixed = true;
 
     RenderObject* o = container();
     if (o) {
-        if (useTransforms && layer() && layer()->transform()) {
+        if (useTransforms && m_layer && m_layer->transform()) {
             fixed = false;  // Elements with transforms act as a containing block for fixed position descendants
-            localPoint = layer()->transform()->mapPoint(localPoint);
+            localPoint = m_layer->transform()->mapPoint(localPoint);
         }
 
         localPoint += offsetFromContainer(o);
 
         return o->localToAbsolute(localPoint, fixed, useTransforms);
     }
     
     return FloatPoint();
 }
 
 FloatPoint RenderBox::absoluteToLocal(FloatPoint containerPoint, bool fixed, bool useTransforms) const
 {
     // We don't expect absoluteToLocal() to be called during layout (yet)
     ASSERT(!view() || !view()->layoutStateEnabled());
     
     if (style()->position() == FixedPosition)
         fixed = true;
 
-    if (useTransforms && layer() && layer()->transform())
+    if (useTransforms && m_layer && m_layer->transform())
         fixed = false;
     
     RenderObject* o = container();
     if (o) {
         FloatPoint localPoint = o->absoluteToLocal(containerPoint, fixed, useTransforms);
         localPoint -= offsetFromContainer(o);
-        if (useTransforms && layer() && layer()->transform())
-            localPoint = layer()->transform()->inverse().mapPoint(localPoint);
+        if (useTransforms && m_layer && m_layer->transform())
+            localPoint = m_layer->transform()->inverse().mapPoint(localPoint);
         return localPoint;
     }
     
     return FloatPoint();
 }
 
-FloatQuad RenderBox::localToContainerQuad(const FloatQuad& localQuad, RenderBoxModelObject* repaintContainer, bool fixed) const
+FloatQuad RenderBox::localToContainerQuad(const FloatQuad& localQuad, RenderBox* repaintContainer, bool fixed) const
 {
     if (repaintContainer == this)
         return localQuad;
 
     if (style()->position() == FixedPosition)
         fixed = true;
 
     RenderObject* o = container();
     if (o) {
         FloatQuad quad = localQuad;
-        if (layer() && layer()->transform()) {
+        if (m_layer && m_layer->transform()) {
             fixed = false;  // Elements with transforms act as a containing block for fixed position descendants
-            quad = layer()->transform()->mapQuad(quad);
+            quad = m_layer->transform()->mapQuad(quad);
         }
         quad += offsetFromContainer(o);
         return o->localToContainerQuad(quad, repaintContainer, fixed);
     }
     
     return FloatQuad();
 }
 
 IntSize RenderBox::offsetFromContainer(RenderObject* o) const
 {
@@ skipping 32 matching lines @@
         } else
             m_inlineBoxWrapper->dirtyLineBoxes();
     }
 }
 
 void RenderBox::position(InlineBox* box)
 {
     if (isPositioned()) {
         // Cache the x position only if we were an INLINE type originally.
         bool wasInline = style()->isOriginalDisplayInlineType();
-        if (wasInline && style()->hasStaticX()) {
+        if (wasInline && hasStaticX()) {
             // The value is cached in the xPos of the box.  We only need this value if
             // our object was inline originally, since otherwise it would have ended up underneath
             // the inlines.
-            layer()->setStaticX(box->xPos());
+            setStaticX(box->xPos());
             setChildNeedsLayout(true, false); // Just go ahead and mark the positioned object as needing layout, so it will update its position properly.
-        } else if (!wasInline && style()->hasStaticY()) {
+        } else if (!wasInline && hasStaticY()) {
             // Our object was a block originally, so we make our normal flow position be
             // just below the line box (as though all the inlines that came before us got
             // wrapped in an anonymous block, which is what would have happened had we been
             // in flow).  This value was cached in the yPos() of the box.
-            layer()->setStaticY(box->yPos());
+            setStaticY(box->yPos());
             setChildNeedsLayout(true, false); // Just go ahead and mark the positioned object as needing layout, so it will update its position properly.
         }
 
         // Nuke the box.
         box->remove();
         box->destroy(renderArena());
     } else if (isReplaced()) {
         setLocation(box->xPos(), box->yPos());
         m_inlineBoxWrapper = box;
     }
 }
 
 void RenderBox::deleteLineBoxWrapper()
 {
     if (m_inlineBoxWrapper) {
         if (!documentBeingDestroyed())
             m_inlineBoxWrapper->remove();
         m_inlineBoxWrapper->destroy(renderArena());
         m_inlineBoxWrapper = 0;
     }
 }
 
-IntRect RenderBox::clippedOverflowRectForRepaint(RenderBoxModelObject* repaintContainer)
+IntRect RenderBox::clippedOverflowRectForRepaint(RenderBox* repaintContainer)
 {
     if (style()->visibility() != VISIBLE && !enclosingLayer()->hasVisibleContent())
         return IntRect();
 
     IntRect r = overflowRect(false);
 
     RenderView* v = view();
     if (v) {
         // FIXME: layoutDelta needs to be applied in parts before/after transforms and
         // repaint containers. https://bugs.webkit.org/show_bug.cgi?id=23308
         r.move(v->layoutDelta());
     }
     
     if (style()) {
         if (style()->hasAppearance())
             // The theme may wish to inflate the rect used when repainting.
             theme()->adjustRepaintRect(this, r);
 
         // We have to use maximalOutlineSize() because a child might have an outline
         // that projects outside of our overflowRect.
         if (v) {
             ASSERT(style()->outlineSize() <= v->maximalOutlineSize());
             r.inflate(v->maximalOutlineSize());
         }
     }
     computeRectForRepaint(repaintContainer, r);
     return r;
 }
 
-void RenderBox::computeRectForRepaint(RenderBoxModelObject* repaintContainer, IntRect& rect, bool fixed)
+void RenderBox::computeRectForRepaint(RenderBox* repaintContainer, IntRect& rect, bool fixed)
 {
     if (RenderView* v = view()) {
         // LayoutState is only valid for root-relative repainting
         if (v->layoutStateEnabled() && !repaintContainer) {
             LayoutState* layoutState = v->layoutState();
-            if (style()->position() == RelativePosition && layer())
-                rect.move(layer()->relativePositionOffset());
+            if (style()->position() == RelativePosition && m_layer)
+                rect.move(m_layer->relativePositionOffset());
 
             rect.move(x(), y());
             rect.move(layoutState->m_offset);
             if (layoutState->m_clipped)
                 rect.intersect(layoutState->m_clipRect);
             return;
         }
     }
 
     if (hasReflection())
@@ skipping 17 matching lines @@
         if (cb->hasColumns()) {
             IntRect repaintRect(topLeft, rect.size());
             cb->adjustRectForColumns(repaintRect);
             topLeft = repaintRect.location();
             rect = repaintRect;
         }
     }
 
     // We are now in our parent container's coordinate space.  Apply our transform to obtain a bounding box
     // in the parent's coordinate space that encloses us.
-    if (layer() && layer()->transform()) {
+    if (m_layer && m_layer->transform()) {
         fixed = false;
-        rect = layer()->transform()->mapRect(rect);
+        rect = m_layer->transform()->mapRect(rect);
         // FIXME: this clobbers topLeft adjustment done for multicol above
         topLeft = rect.location();
         topLeft.move(x(), y());
     }
 
     if (style()->position() == AbsolutePosition && o->isRelPositioned() && o->isRenderInline())
         topLeft += toRenderInline(o)->relativePositionedInlineOffset(this);
-    else if (style()->position() == RelativePosition && layer()) {
+    else if (style()->position() == RelativePosition && m_layer) {
         // Apply the relative position offset when invalidating a rectangle.  The layer
         // is translated, but the render box isn't, so we need to do this to get the
         // right dirty rect.  Since this is called from RenderObject::setStyle, the relative position
         // flag on the RenderObject has been cleared, so use the one on the style().
-        topLeft += layer()->relativePositionOffset();
+        topLeft += m_layer->relativePositionOffset();
     }
     
     // FIXME: We ignore the lightweight clipping rect that controls use, since if |o| is in mid-layout,
     // its controlClipRect will be wrong. For overflow clip we use the values cached by the layer.
     if (o->hasOverflowClip()) {
         RenderBox* containerBox = toRenderBox(o);
 
         // o->height() is inaccurate if we're in the middle of a layout of |o|, so use the
         // layer's size instead.  Even if the layer's size is wrong, the layer itself will repaint
         // anyway if its size does change.
@@ skipping 21 matching lines @@
         // since the object may not have gotten a layout.
         m_frameRect = rect;
         repaint();
         repaintOverhangingFloats(true);
         m_frameRect = IntRect(newX, newY, newWidth, newHeight);
         repaint();
         repaintOverhangingFloats(true);
     }
 }
 
+int RenderBox::relativePositionOffsetX() const
+{
+    if (!style()->left().isAuto()) {
+        if (!style()->right().isAuto() && containingBlock()->style()->direction() == RTL)
+            return -style()->right().calcValue(containingBlockWidth());
+        return style()->left().calcValue(containingBlockWidth());
+    }
+    if (!style()->right().isAuto())
+        return -style()->right().calcValue(containingBlockWidth());
+    return 0;
+}
+
+int RenderBox::relativePositionOffsetY() const
+{
+    if (!style()->top().isAuto()) {
+        if (!style()->top().isPercent() || containingBlock()->style()->height().isFixed())
+            return style()->top().calcValue(containingBlockHeight());
+    } else if (!style()->bottom().isAuto()) {
+        if (!style()->bottom().isPercent() || containingBlock()->style()->height().isFixed())
+            return -style()->bottom().calcValue(containingBlockHeight());
+    }
+    return 0;
+}
+
 void RenderBox::calcWidth()
 {
     if (isPositioned()) {
         calcAbsoluteHorizontal();
         return;
     }
 
     // If layout is limited to a subtree, the subtree root's width does not change.
     if (node() && view()->frameView() && view()->frameView()->layoutRoot(true) == this)
         return;
@@ skipping 422 matching lines @@
     // We need to stop here, since we don't want to increase the height of the table
     // artificially.  We're going to rely on this cell getting expanded to some new
     // height, and then when we lay out again we'll use the calculation below.
     if (isTableCell() && (h.isAuto() || h.isPercent()))
         return overrideSize() - (borderLeft() + borderRight() + paddingLeft() + paddingRight());
 
     if (h.isPercent())
        return calcContentBoxHeight(h.calcValue(containingBlock()->availableHeight()));
 
     if (isRenderBlock() && isPositioned() && style()->height().isAuto() && !(style()->top().isAuto() || style()->bottom().isAuto())) {
-        RenderBlock* block = const_cast<RenderBlock*>(toRenderBlock(this));
+        RenderBlock* block = const_cast<RenderBlock*>(static_cast<const RenderBlock*>(this));
         int oldHeight = block->height();
         block->calcHeight();
         int newHeight = block->calcContentBoxHeight(block->contentHeight());
         block->setHeight(oldHeight);
         return calcContentBoxHeight(newHeight);
     }
 
     return containingBlock()->availableHeight();
 }
 
 void RenderBox::calcVerticalMargins()
 {
     if (isTableCell()) {
         m_marginTop = 0;
         m_marginBottom = 0;
         return;
     }
 
     // margins are calculated with respect to the _width_ of
     // the containing block (8.3)
     int cw = containingBlock()->contentWidth();
 
     m_marginTop = style()->marginTop().calcMinValue(cw);
     m_marginBottom = style()->marginBottom().calcMinValue(cw);
 }
 
+int RenderBox::staticX() const
+{
+    return m_layer ? m_layer->staticX() : 0;
+}
+
+int RenderBox::staticY() const
+{
+    return m_layer ? m_layer->staticY() : 0;
+}
+
+void RenderBox::setStaticX(int staticX)
+{
+    ASSERT(isPositioned() || isRelPositioned());
+    m_layer->setStaticX(staticX);
+}
+
+void RenderBox::setStaticY(int staticY)
+{
+    ASSERT(isPositioned() || isRelPositioned());
+    
+    if (staticY == m_layer->staticY())
+        return;
+    
+    m_layer->setStaticY(staticY);
+    setChildNeedsLayout(true, false);
+}
+
 int RenderBox::containingBlockWidthForPositioned(const RenderObject* containingBlock) const
 {
     if (containingBlock->isRenderInline()) {
         ASSERT(containingBlock->isRelPositioned());
 
         const RenderInline* flow = toRenderInline(containingBlock);
         InlineFlowBox* first = flow->firstLineBox();
         InlineFlowBox* last = flow->lastLineBox();
 
         // If the containing block is empty, return a width of 0.
@@ skipping 101 matching lines @@
      * fixed positioned elements is the initial containing block instead of the
      * viewport, and all scrollable boxes should be assumed to be scrolled to their
      * origin.
     \*---------------------------------------------------------------------------*/
 
     // see FIXME 2
     // Calculate the static distance if needed.
     if (left.isAuto() && right.isAuto()) {
         if (containerDirection == LTR) {
             // 'staticX' should already have been set through layout of the parent.
-            int staticPosition = layer()->staticX() - containerBlock->borderLeft();
+            int staticPosition = staticX() - containerBlock->borderLeft();
             for (RenderBox* po = parentBox(); po && po != containerBlock; po = po->parentBox())
                 staticPosition += po->x();
             left.setValue(Fixed, staticPosition);
         } else {
             RenderBox* po = parentBox();
             // 'staticX' should already have been set through layout of the parent.
-            int staticPosition = layer()->staticX() + containerWidth + containerBlock->borderRight() - po->width();
+            int staticPosition = staticX() + containerWidth + containerBlock->borderRight() - po->width();
             for (; po && po != containerBlock; po = po->parentBox())
                 staticPosition -= po->x();
             right.setValue(Fixed, staticPosition);
         }
     }
 
     // Calculate constraint equation values for 'width' case.
     int widthResult;
     int xResult;
     calcAbsoluteHorizontalValues(style()->width(), containerBlock, containerDirection,
@@ skipping 267 matching lines @@
      *
      * For the purposes of calculating the static position, the containing block
      * of fixed positioned elements is the initial containing block instead of
      * the viewport.
     \*---------------------------------------------------------------------------*/
 
     // see FIXME 2
     // Calculate the static distance if needed.
     if (top.isAuto() && bottom.isAuto()) {
         // staticY should already have been set through layout of the parent()
-        int staticTop = layer()->staticY() - containerBlock->borderTop();
+        int staticTop = staticY() - containerBlock->borderTop();
         for (RenderBox* po = parentBox(); po && po != containerBlock; po = po->parentBox()) {
             if (!po->isTableRow())
                 staticTop += po->y();
         }
         top.setValue(Fixed, staticTop);
     }
 
 
     int h; // Needed to compute overflow.
     int y;
@@ skipping 206 matching lines @@
     /*-----------------------------------------------------------------------*\
      * 2. If both 'left' and 'right' have the value 'auto', then if 'direction'
      *    of the containing block is 'ltr', set 'left' to the static position;
      *    else if 'direction' is 'rtl', set 'right' to the static position.
     \*-----------------------------------------------------------------------*/
     // see FIXME 2
     if (left.isAuto() && right.isAuto()) {
         // see FIXME 1
         if (containerDirection == LTR) {
             // 'staticX' should already have been set through layout of the parent.
-            int staticPosition = layer()->staticX() - containerBlock->borderLeft();
+            int staticPosition = staticX() - containerBlock->borderLeft();
             for (RenderBox* po = parentBox(); po && po != containerBlock; po = po->parentBox())
                 staticPosition += po->x();
             left.setValue(Fixed, staticPosition);
         } else {
             RenderBox* po = parentBox();
             // 'staticX' should already have been set through layout of the parent.
-            int staticPosition = layer()->staticX() + containerWidth + containerBlock->borderRight() - po->width();
+            int staticPosition = staticX() + containerWidth + containerBlock->borderRight() - po->width();
             for (; po && po != containerBlock; po = po->parentBox())
                 staticPosition -= po->x();
             right.setValue(Fixed, staticPosition);
         }
     }
 
     /*-----------------------------------------------------------------------*\
      * 3. If 'left' or 'right' are 'auto', replace any 'auto' on 'margin-left'
      *    or 'margin-right' with '0'.
     \*-----------------------------------------------------------------------*/
@@ skipping 138 matching lines @@
     setHeight(calcReplacedHeight() + borderTop() + borderBottom() + paddingTop() + paddingBottom());
     const int availableSpace = containerHeight - height();
 
     /*-----------------------------------------------------------------------*\
      * 2. If both 'top' and 'bottom' have the value 'auto', replace 'top'
      *    with the element's static position.
     \*-----------------------------------------------------------------------*/
     // see FIXME 2
     if (top.isAuto() && bottom.isAuto()) {
         // staticY should already have been set through layout of the parent().
-        int staticTop = layer()->staticY() - containerBlock->borderTop();
+        int staticTop = staticY() - containerBlock->borderTop();
         for (RenderBox* po = parentBox(); po && po != containerBlock; po = po->parentBox()) {
             if (!po->isTableRow())
                 staticTop += po->y();
         }
         top.setValue(Fixed, staticTop);
     }
 
     /*-----------------------------------------------------------------------*\
      * 3. If 'bottom' is 'auto', replace any 'auto' on 'margin-top' or
      *    'margin-bottom' with '0'.
@@ skipping 249 matching lines @@
 #if ENABLE(SVG)
 
 TransformationMatrix RenderBox::localTransform() const
 {
     return TransformationMatrix(1, 0, 0, 1, x(), y());
 }
 
 #endif
 
 } // namespace WebCore