Remove dead position:relative code.

sky/engine/core/rendering/RenderInline.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 333 matching lines @@
     return computeMargin(this, style()->marginBeforeUsing(otherStyle ? otherStyle : style()));
 }
 
 LayoutUnit RenderInline::marginAfter(const RenderStyle* otherStyle) const
 {
     return computeMargin(this, style()->marginAfterUsing(otherStyle ? otherStyle : style()));
 }
 
 const char* RenderInline::renderName() const
 {
-    if (isRelPositioned())
-        return "RenderInline (relative positioned)";
-    if (isAnonymous())
-        return "RenderInline (generated)";
     return "RenderInline";
 }
 
 bool RenderInline::nodeAtPoint(const HitTestRequest& request, HitTestResult& result,
                                 const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset)
 {
     return m_lineBoxes.hitTest(this, request, result, locationInContainer, accumulatedOffset);
 }
 
 namespace {
@@ skipping 209 matching lines @@
     RootInlineBox& lastRootBox = lastLineBox()->root();
 
     LayoutUnit logicalTop = firstLineBox()->logicalTopVisualOverflow(firstRootBox.lineTop());
     LayoutUnit logicalWidth = logicalRightSide - logicalLeftSide;
     LayoutUnit logicalHeight = lastLineBox()->logicalBottomVisualOverflow(lastRootBox.lineBottom()) - logicalTop;
 
     LayoutRect rect(logicalLeftSide, logicalTop, logicalWidth, logicalHeight);
     return rect;
 }
 
-LayoutSize RenderInline::offsetFromContainer(const RenderObject* container, const LayoutPoint& point, bool* offsetDependsOnPoint) const
-{
-    ASSERT(container == this->container());
-
-    LayoutSize offset;
-    if (isRelPositioned())
-        offset += offsetForInFlowPosition();
-
-    // FIXME(sky): Remove now that it's always false?
-    if (offsetDependsOnPoint)
-        *offsetDependsOnPoint = false;
-
-    return offset;
-}
-
 void RenderInline::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode) const
 {
     if (paintInvalidationContainer == this)
         return;
 
     bool containerSkipped;
     RenderObject* o = container(paintInvalidationContainer, &containerSkipped);
     if (!o)
         return;
 
@@ skipping 92 matching lines @@
     return style()->computedLineHeight();
 }
 
 int RenderInline::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const
 {
     ASSERT(linePositionMode == PositionOnContainingLine);
     const FontMetrics& fontMetrics = style(firstLine)->fontMetrics();
     return fontMetrics.ascent(baselineType) + (lineHeight(firstLine, direction, linePositionMode) - fontMetrics.height()) / 2;
 }
 
-LayoutSize RenderInline::offsetForInFlowPositionedInline(const RenderBox& child) const
-{
-    // FIXME: This function isn't right with mixed writing modes.
-
-    ASSERT(isRelPositioned());
-    if (!isRelPositioned())
-        return LayoutSize();
-
-    // When we have an enclosing relpositioned inline, we need to add in the offset of the first line
-    // box from the rest of the content, but only in the cases where we know we're positioned
-    // relative to the inline itself.
-
-    LayoutSize logicalOffset;
-    LayoutUnit inlinePosition;
-    LayoutUnit blockPosition;
-    if (firstLineBox()) {
-        inlinePosition = LayoutUnit::fromFloatRound(firstLineBox()->logicalLeft());
-        blockPosition = firstLineBox()->logicalTop();
-    } else {
-        inlinePosition = layer()->staticInlinePosition();
-        blockPosition = layer()->staticBlockPosition();
-    }
-
-    // Per http://www.w3.org/TR/CSS2/visudet.html#abs-non-replaced-width an absolute positioned box
-    // with a static position should locate itself as though it is a normal flow box in relation to
-    // its containing block. If this relative-positioned inline has a negative offset we need to
-    // compensate for it so that we align the positioned object with the edge of its containing block.
-    if (child.style()->hasStaticInlinePosition())
-        logicalOffset.setWidth(std::max(LayoutUnit(), -offsetForInFlowPosition().width()));
-    else
-        logicalOffset.setWidth(inlinePosition);
-
-    if (!child.style()->hasStaticBlockPosition())
-        logicalOffset.setHeight(blockPosition);
-
-    return logicalOffset;
-}
-
 namespace {
 
 class AbsoluteRectsIgnoringEmptyRectsGeneratorContext : public AbsoluteRectsGeneratorContext {
 public:
     AbsoluteRectsIgnoringEmptyRectsGeneratorContext(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset)
         : AbsoluteRectsGeneratorContext(rects, accumulatedOffset) { }
 
     void operator()(const FloatRect& rect)
     {
         if (!rect.isEmpty())
             AbsoluteRectsGeneratorContext::operator()(rect);
     }
 };
 
 } // unnamed namespace
 
 void RenderInline::addFocusRingRects(Vector<IntRect>& rects, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer) const
 {
     AbsoluteRectsIgnoringEmptyRectsGeneratorContext context(rects, additionalOffset);
     generateLineBoxRects(context);
 
     addChildFocusRingRects(rects, additionalOffset, paintContainer);
 }
 
 } // namespace blink