Remove dead position:relative code.

sky/engine/core/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, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. 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
@@ skipping 1097 matching lines @@
     }
 
     mode &= ~ApplyContainerFlip;
 
     o->mapLocalToContainer(paintInvalidationContainer, transformState, mode);
 }
 
 LayoutSize RenderBox::offsetFromContainer(const RenderObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
 {
     ASSERT(o == container());
-
-    LayoutSize offset;
-    if (isRelPositioned())
-        offset += offsetForInFlowPosition();
-
     if (!isInline() || isReplaced())
-        offset += locationOffset();
-
-    if (style()->position() == AbsolutePosition && o->isRelPositioned() && o->isRenderInline())
-        offset += toRenderInline(o)->offsetForInFlowPositionedInline(*this);
-
-    return offset;
+        return locationOffset();
+    return LayoutSize();
 }
 
 InlineBox* RenderBox::createInlineBox()
 {
     return new InlineBox(*this);
 }
 
 void RenderBox::dirtyLineBoxes(bool fullLayout)
 {
     if (inlineBoxWrapper()) {
@@ skipping 23 matching lines @@
         } else {
             // 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 y() of the box.
             layer()->setStaticBlockPosition(box->logicalTop());
             if (style()->hasStaticBlockPosition())
                 setChildNeedsLayout(MarkOnlyThis); // Just go ahead and mark the positioned object as needing layout, so it will update its position properly.
         }
 
-        if (container()->isRenderInline())
-            moveWithEdgeOfInlineContainerIfNecessary();
-
         // Nuke the box.
         box->remove(DontMarkLineBoxes);
         box->destroy();
     } else if (isReplaced()) {
         setLocation(roundedLayoutPoint(box->topLeft()));
         setInlineBoxWrapper(box);
     }
 }
 
-void RenderBox::moveWithEdgeOfInlineContainerIfNecessary()
-{
-    ASSERT(isOutOfFlowPositioned() && container()->isRenderInline() && container()->isRelPositioned());
-    // If this object is inside a relative positioned inline and its inline position is an explicit offset from the edge of its container
-    // then it will need to move if its inline container has changed width. We do not track if the width has changed
-    // but if we are here then we are laying out lines inside it, so it probably has - mark our object for layout so that it can
-    // move to the new offset created by the new width.
-    if (!normalChildNeedsLayout() && !style()->hasStaticInlinePosition())
-        setChildNeedsLayout(MarkOnlyThis);
-}
-
 void RenderBox::deleteLineBoxWrapper()
 {
     if (inlineBoxWrapper()) {
         if (!documentBeingDestroyed())
             inlineBoxWrapper()->remove();
         inlineBoxWrapper()->destroy();
         ASSERT(m_rareData);
         m_rareData->m_inlineBoxWrapper = 0;
     }
 }
@@ skipping 594 matching lines @@
         style()->marginBeforeUsing(containingBlock->style()),
         style()->marginAfterUsing(containingBlock->style()));
     // Note that in this 'positioning phase' of the layout we are using the containing block's writing mode rather than our own when calculating margins.
     // See http://www.w3.org/TR/2014/CR-css-writing-modes-3-20140320/#orthogonal-flows
     containingBlock->setMarginBeforeForChild(this, marginBefore);
     containingBlock->setMarginAfterForChild(this, marginAfter);
 }
 
 LayoutUnit RenderBox::containingBlockLogicalWidthForPositioned(const RenderBoxModelObject* containingBlock) const
 {
-    if (containingBlock->isBox())
-        return toRenderBox(containingBlock)->clientLogicalWidth();
-
-    ASSERT(containingBlock->isRenderInline() && 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.
-    if (!first || !last)
-        return 0;
-
-    LayoutUnit fromLeft;
-    LayoutUnit fromRight;
-    if (containingBlock->style()->isLeftToRightDirection()) {
-        fromLeft = first->logicalLeft() + first->borderLogicalLeft();
-        fromRight = last->logicalLeft() + last->logicalWidth() - last->borderLogicalRight();
-    } else {
-        fromRight = first->logicalLeft() + first->logicalWidth() - first->borderLogicalRight();
-        fromLeft = last->logicalLeft() + last->borderLogicalLeft();
-    }
-
-    return std::max<LayoutUnit>(0, fromRight - fromLeft);
+    ASSERT(containingBlock->isBox());
+    return toRenderBox(containingBlock)->clientLogicalWidth();
 }
 
 LayoutUnit RenderBox::containingBlockLogicalHeightForPositioned(const RenderBoxModelObject* containingBlock) const
 {
-    if (containingBlock->isBox()) {
-        const RenderBlock* cb = containingBlock->isRenderBlock() ?
-            toRenderBlock(containingBlock) : containingBlock->containingBlock();
-        return cb->clientLogicalHeight();
-    }
-
-    ASSERT(containingBlock->isRenderInline() && containingBlock->isRelPositioned());
-
-    const RenderInline* flow = toRenderInline(containingBlock);
-    InlineFlowBox* first = flow->firstLineBox();
-    InlineFlowBox* last = flow->lastLineBox();
-
-    // If the containing block is empty, return a height of 0.
-    if (!first || !last)
-        return 0;
-
-    LayoutRect boundingBox = flow->linesBoundingBox();
-    LayoutUnit heightResult = boundingBox.height();
-    heightResult -= (containingBlock->borderBefore() + containingBlock->borderAfter());
-    return heightResult;
+    ASSERT(containingBlock->isBox());
+    const RenderBlock* cb = containingBlock->isRenderBlock() ?
+        toRenderBlock(containingBlock) : containingBlock->containingBlock();
+    return cb->clientLogicalHeight();
 }
 
 static void computeInlineStaticDistance(Length& logicalLeft, Length& logicalRight, const RenderBox* child, const RenderBoxModelObject* containerBlock, LayoutUnit containerLogicalWidth)
 {
     if (!logicalLeft.isAuto() || !logicalRight.isAuto())
         return;
 
     // FIXME: The static distance computation has not been patched for mixed writing modes yet.
     if (child->parent()->style()->direction() == LTR) {
         LayoutUnit staticPosition = child->layer()->staticInlinePosition() - containerBlock->borderLogicalLeft();
         for (RenderObject* curr = child->parent(); curr && curr != containerBlock; curr = curr->container()) {
-            if (curr->isBox()) {
+            if (curr->isBox())
                 staticPosition += toRenderBox(curr)->logicalLeft();
-                if (toRenderBox(curr)->isRelPositioned())
-                    staticPosition += toRenderBox(curr)->relativePositionOffset().width();
-            } else if (curr->isInline()) {
-                if (curr->isRelPositioned()) {
-                    if (!curr->style()->logicalLeft().isAuto())
-                        staticPosition += curr->style()->logicalLeft().value();
-                    else
-                        staticPosition -= curr->style()->logicalRight().value();
-                }
-            }
         }
         logicalLeft.setValue(Fixed, staticPosition);
     } else {
         RenderBox* enclosingBox = child->parent()->enclosingBox();
         LayoutUnit staticPosition = child->layer()->staticInlinePosition() + containerLogicalWidth + containerBlock->borderLogicalLeft();
         for (RenderObject* curr = child->parent(); curr; curr = curr->container()) {
             if (curr->isBox()) {
-                if (curr != containerBlock) {
+                if (curr != containerBlock)
                     staticPosition -= toRenderBox(curr)->logicalLeft();
-                    if (toRenderBox(curr)->isRelPositioned())
-                        staticPosition -= toRenderBox(curr)->relativePositionOffset().width();
-                }
                 if (curr == enclosingBox)
                     staticPosition -= enclosingBox->logicalWidth();
-            } else if (curr->isInline()) {
-                if (curr->isRelPositioned()) {
-                    if (!curr->style()->logicalLeft().isAuto())
-                        staticPosition -= curr->style()->logicalLeft().value();
-                    else
-                        staticPosition += curr->style()->logicalRight().value();
-                }
             }
             if (curr == containerBlock)
                 break;
         }
         logicalRight.setValue(Fixed, staticPosition);
     }
 }
 
 void RenderBox::computePositionedLogicalWidth(LogicalExtentComputedValues& computedValues) const
 {
@@ skipping 1173 matching lines @@
 
 LayoutRect RenderBox::layoutOverflowRectForPropagation() const
 {
     // Only propagate interior layout overflow if we don't clip it.
     LayoutRect rect = borderBoxRect();
     rect.expand(LayoutSize(LayoutUnit(), marginAfter()));
 
     if (!hasOverflowClip())
         rect.unite(layoutOverflowRect());
 
-    bool hasTransform = hasLayer() && layer()->transform();
-    if (isRelPositioned() || hasTransform) {
-        if (hasTransform)
-            rect = layer()->currentTransform().mapRect(rect);
-
-        if (isRelPositioned())
-            rect.move(offsetForInFlowPosition());
-    }
+    if (hasLayer() && layer()->transform())
+        rect = layer()->currentTransform().mapRect(rect);
 
     return rect;
 }
 
 LayoutUnit RenderBox::offsetLeft() const
 {
     return adjustedPositionRelativeToOffsetParent(location()).x();
 }
 
 LayoutUnit RenderBox::offsetTop() const
@@ skipping 10 matching lines @@
 
 RenderBox::BoxDecorationData::BoxDecorationData(const RenderStyle& style)
 {
     backgroundColor = style.colorIncludingFallback(CSSPropertyBackgroundColor);
     hasBackground = backgroundColor.alpha() || style.hasBackgroundImage();
     ASSERT(hasBackground == style.hasBackground());
     hasBorder = style.hasBorder();
 }
 
 } // namespace blink