Remove some more assorted code from RenderBox.

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 1201 matching lines @@
         clipRect.move(0, c);
         clipRect.contract(0, c);
     }
 
     if (!style()->clipBottom().isAuto())
         clipRect.contract(0, height() - valueForLength(style()->clipBottom(), height()));
 
     return clipRect;
 }
 
-static LayoutUnit portionOfMarginNotConsumedByFloat(LayoutUnit childMargin, LayoutUnit contentSide, LayoutUnit offset)
-{
-    if (childMargin <= 0)
-        return 0;
-    LayoutUnit contentSideWithMargin = contentSide + childMargin;
-    if (offset > contentSideWithMargin)
-        return childMargin;
-    return offset - contentSide;
-}
-
-LayoutUnit RenderBox::shrinkLogicalWidthToAvoidFloats(LayoutUnit childMarginStart, LayoutUnit childMarginEnd, const RenderBlockFlow* cb) const
-{
-    LayoutUnit width = cb->availableLogicalWidthForLine(false) - std::max<LayoutUnit>(0, childMarginStart) - std::max<LayoutUnit>(0, childMarginEnd);
-
-    // We need to see if margins on either the start side or the end side can contain the floats in question. If they can,
-    // then just using the line width is inaccurate. In the case where a float completely fits, we don't need to use the line
-    // offset at all, but can instead push all the way to the content edge of the containing block. In the case where the float
-    // doesn't fit, we can use the line offset, but we need to grow it by the margin to reflect the fact that the margin was
-    // "consumed" by the float. Negative margins aren't consumed by the float, and so we ignore them.
-    width += portionOfMarginNotConsumedByFloat(childMarginStart, cb->startOffsetForContent(), cb->startOffsetForLine(false));
-    width += portionOfMarginNotConsumedByFloat(childMarginEnd, cb->endOffsetForContent(), cb->endOffsetForLine(false));
-    return width;
-}
-
 LayoutUnit RenderBox::containingBlockLogicalHeightForContent(AvailableLogicalHeightType heightType) const
 {
     return containingBlock()->availableLogicalHeight(heightType);
 }
 
-LayoutUnit RenderBox::containingBlockAvailableLineWidth() const
-{
-    RenderBlock* cb = containingBlock();
-    if (cb->isRenderBlockFlow())
-        return toRenderBlockFlow(cb)->availableLogicalWidthForLine(false);
-    return 0;
-}
-
 void RenderBox::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, const PaintInvalidationState* paintInvalidationState) const
 {
     if (paintInvalidationContainer == this)
         return;
 
     if (paintInvalidationState && paintInvalidationState->canMapToContainer(paintInvalidationContainer)) {
         LayoutSize offset = paintInvalidationState->paintOffset() + locationOffset();
         if (style()->hasInFlowPosition() && layer())
             offset += layer()->offsetForInFlowPosition();
         transformState.move(offset);
@@ skipping 30 matching lines @@
 
 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 += topLeftLocationOffset();
+        offset += locationOffset();
 
     if (o->hasOverflowClip())
         offset -= toRenderBox(o)->scrolledContentOffset();
 
     if (style()->position() == AbsolutePosition && o->isRelPositioned() && o->isRenderInline())
         offset += toRenderInline(o)->offsetForInFlowPositionedInline(*this);
 
     return offset;
 }
 
@@ skipping 1977 matching lines @@
     }
 
     return LayoutBoxExtent(top, right, bottom, left);
 }
 
 void RenderBox::addOverflowFromChild(RenderBox* child, const LayoutSize& delta)
 {
     // Only propagate layout overflow from the child if the child isn't clipping its overflow.  If it is, then
     // its overflow is internal to it, and we don't care about it.  layoutOverflowRectForPropagation takes care of this
     // and just propagates the border box rect instead.
-    LayoutRect childLayoutOverflowRect = child->layoutOverflowRectForPropagation(style());
+    LayoutRect childLayoutOverflowRect = child->layoutOverflowRectForPropagation();
     childLayoutOverflowRect.move(delta);
     addLayoutOverflow(childLayoutOverflowRect);
 
     // Add in visual overflow from the child.  Even if the child clips its overflow, it may still
     // have visual overflow of its own set from box shadows or reflections.  It is unnecessary to propagate this
     // overflow if we are clipping our own overflow.
     if (child->hasSelfPaintingLayer())
         return;
-    LayoutRect childVisualOverflowRect = child->visualOverflowRectForPropagation(style());
+    LayoutRect childVisualOverflowRect = child->visualOverflowRect();
     childVisualOverflowRect.move(delta);
     addContentsVisualOverflow(childVisualOverflowRect);
 }
 
 void RenderBox::addLayoutOverflow(const LayoutRect& rect)
 {
-    LayoutRect clientBox = noOverflowRect();
+    LayoutRect clientBox = paddingBoxRect();
     if (clientBox.contains(rect) || rect.isEmpty())
         return;
 
     // For overflow clip objects, we don't want to propagate overflow into unreachable areas.
     LayoutRect overflowRect(rect);
     if (hasOverflowClip() || isRenderView()) {
         // Overflow is in the block's coordinate space and thus is flipped for horizontal-bt and vertical-rl
         // writing modes.  At this stage that is actually a simplification, since we can treat horizontal-tb/bt as the same
         // and vertical-lr/rl as the same.
         bool hasTopOverflow = false;
@@ skipping 27 matching lines @@
     m_overflow->addLayoutOverflow(overflowRect);
 }
 
 void RenderBox::addVisualOverflow(const LayoutRect& rect)
 {
     LayoutRect borderBox = borderBoxRect();
     if (borderBox.contains(rect) || rect.isEmpty())
         return;
 
     if (!m_overflow)
-        m_overflow = adoptPtr(new RenderOverflow(noOverflowRect(), borderBox));
+        m_overflow = adoptPtr(new RenderOverflow(paddingBoxRect(), borderBox));
 
     m_overflow->addVisualOverflow(rect);
 }
 
 void RenderBox::addContentsVisualOverflow(const LayoutRect& rect)
 {
     if (!hasOverflowClip()) {
         addVisualOverflow(rect);
         return;
     }
 
     if (!m_overflow)
-        m_overflow = adoptPtr(new RenderOverflow(noOverflowRect(), borderBoxRect()));
+        m_overflow = adoptPtr(new RenderOverflow(paddingBoxRect(), borderBoxRect()));
     m_overflow->addContentsVisualOverflow(rect);
 }
 
 void RenderBox::clearLayoutOverflow()
 {
     if (!m_overflow)
         return;
 
     if (!hasVisualOverflow() && contentsVisualOverflowRect().isEmpty()) {
         clearAllOverflows();
         return;
     }
 
-    m_overflow->setLayoutOverflow(noOverflowRect());
+    m_overflow->setLayoutOverflow(paddingBoxRect());
 }
 
 bool RenderBox::percentageLogicalHeightIsResolvableFromBlock(const RenderBlock* containingBlock, bool isOutOfFlowPositioned)
 {
     // In quirks mode, blocks with auto height are skipped, and we keep looking for an enclosing
     // block that may have a specified height and then use it. In strict mode, this violates the
     // specification, which states that percentage heights just revert to auto if the containing
     // block has an auto height. We still skip anonymous containing blocks in both modes, though, and look
     // only at explicit containers.
     const RenderBlock* cb = containingBlock;
@@ skipping 51 matching lines @@
     const RenderObject* curr = this;
     while (curr) {
         RenderLayer* layer = curr->hasLayer() && curr->isBox() ? toRenderBox(curr)->layer() : 0;
         if (layer && layer->isSelfPaintingLayer())
             return layer;
         curr = curr->parent();
     }
     return 0;
 }
 
-LayoutRect RenderBox::logicalVisualOverflowRectForPropagation(RenderStyle* parentStyle) const
-{
-    // FIXME(sky): Remove
-    return visualOverflowRectForPropagation(parentStyle);
-}
-
-LayoutRect RenderBox::visualOverflowRectForPropagation(RenderStyle* parentStyle) const
-{
-    // FIXME(sky): Remove
-    return visualOverflowRect();
-}
-
-LayoutRect RenderBox::logicalLayoutOverflowRectForPropagation(RenderStyle* parentStyle) const
-{
-    // FIXME(sky): Remove
-    return layoutOverflowRectForPropagation(parentStyle);
-}
-
-LayoutRect RenderBox::layoutOverflowRectForPropagation(RenderStyle* parentStyle) const
+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());
     }
 
     return rect;
 }
 
-LayoutRect RenderBox::noOverflowRect() const
-{
-    // FIXME(sky): Replace with borderBoxRect?
-    LayoutUnit left = borderLeft();
-    LayoutUnit top = borderTop();
-    LayoutUnit right = borderRight();
-    LayoutUnit bottom = borderBottom();
-    LayoutRect rect(left, top, width() - left - right, height() - top - bottom);
-    return rect;
-}
-
 LayoutUnit RenderBox::offsetLeft() const
 {
-    return adjustedPositionRelativeToOffsetParent(topLeftLocation()).x();
+    return adjustedPositionRelativeToOffsetParent(location()).x();
 }
 
 LayoutUnit RenderBox::offsetTop() const
 {
-    return adjustedPositionRelativeToOffsetParent(topLeftLocation()).y();
-}
-
-LayoutPoint RenderBox::topLeftLocation() const
-{
-    // FIXME(sky): Remove this.
-    return location();
-}
-
-LayoutSize RenderBox::topLeftLocationOffset() const
-{
-    // FIXME(sky): Remove this.
-    return locationOffset();
+    return adjustedPositionRelativeToOffsetParent(location()).y();
 }
 
 bool RenderBox::hasRelativeLogicalHeight() const
 {
     return style()->logicalHeight().isPercent()
         || style()->logicalMinHeight().isPercent()
         || style()->logicalMaxHeight().isPercent();
 }
 
 static void markBoxForRelayoutAfterSplit(RenderBox* box)
@@ skipping 75 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