Remove more support for floats from RenderBlockFlow.

sky/engine/core/rendering/RenderBlockFlow.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 25 matching lines @@
 #include "core/frame/Settings.h"
 #include "core/rendering/HitTestLocation.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderText.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/line/LineWidth.h"
 #include "platform/text/BidiTextRun.h"
 
 namespace blink {
 
-bool RenderBlockFlow::s_canPropagateFloatIntoSibling = false;
-
 struct SameSizeAsMarginInfo {
     uint16_t bitfields;
     LayoutUnit margins[2];
 };
 
 COMPILE_ASSERT(sizeof(RenderBlockFlow::MarginValues) == sizeof(LayoutUnit[4]), MarginValues_should_stay_small);
 
 class MarginInfo {
     // Collapsing flags for whether we can collapse our margins with our children's margins.
     bool m_canCollapseWithChildren : 1;
@@ skipping 137 matching lines @@
 
     clearNeedsLayout();
 }
 
 inline void RenderBlockFlow::layoutBlockFlow(bool relayoutChildren, SubtreeLayoutScope& layoutScope)
 {
     LayoutUnit oldLeft = logicalLeft();
     bool logicalWidthChanged = updateLogicalWidthAndColumnWidth();
     relayoutChildren |= logicalWidthChanged;
 
-    rebuildFloatsFromIntruding();
-
     LayoutState state(*this, locationOffset(), logicalWidthChanged);
 
     // We use four values, maxTopPos, maxTopNeg, maxBottomPos, and maxBottomNeg, to track
     // our current maximal positive and negative margins. These values are used when we
     // are collapsed with adjacent blocks, so for example, if you have block A and B
     // collapsing together, then you'd take the maximal positive margin from both A and B
     // and subtract it from the maximal negative margin from both A and B to get the
     // true collapsed margin. This algorithm is recursive, so when we finish layout()
     // our block knows its current maximal positive/negative values.
     initMaxMarginValues();
     setHasMarginBeforeQuirk(style()->hasMarginBeforeQuirk());
     setHasMarginAfterQuirk(style()->hasMarginAfterQuirk());
 
     LayoutUnit beforeEdge = borderBefore() + paddingBefore();
     LayoutUnit afterEdge = borderAfter() + paddingAfter() + scrollbarLogicalHeight();
     LayoutUnit previousHeight = logicalHeight();
     setLogicalHeight(beforeEdge);
 
     m_paintInvalidationLogicalTop = 0;
     m_paintInvalidationLogicalBottom = 0;
     if (!firstChild() && !isAnonymousBlock())
         setChildrenInline(true);
 
     if (childrenInline())
         layoutInlineChildren(relayoutChildren, m_paintInvalidationLogicalTop, m_paintInvalidationLogicalBottom, afterEdge);
     else
         layoutBlockChildren(relayoutChildren, layoutScope, beforeEdge, afterEdge);
 
-    // Expand our intrinsic height to encompass floats.
-    if (lowestFloatLogicalBottom() > (logicalHeight() - afterEdge) && createsBlockFormattingContext())
-        setLogicalHeight(lowestFloatLogicalBottom() + afterEdge);
-
-    // Calculate our new height.
-    LayoutUnit oldHeight = logicalHeight();
     LayoutUnit oldClientAfterEdge = clientLogicalBottom();
 
     updateLogicalHeight();
-    LayoutUnit newHeight = logicalHeight();
-    if (oldHeight > newHeight && !childrenInline()) {
-        // One of our children's floats may have become an overhanging float for us.
-        for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
-            if (child->isRenderBlockFlow() && !child->isFloatingOrOutOfFlowPositioned()) {
-                RenderBlockFlow* block = toRenderBlockFlow(child);
-                if (block->lowestFloatLogicalBottom() + block->logicalTop() <= newHeight)
-                    break;
-                addOverhangingFloats(block, false);
-            }
-        }
-    }
 
-    bool heightChanged = (previousHeight != newHeight);
-    if (heightChanged)
+    if (previousHeight != logicalHeight())
         relayoutChildren = true;
 
     layoutPositionedObjects(relayoutChildren || isDocumentElement(), oldLeft != logicalLeft() ? ForcedLayoutAfterContainingBlockMoved : DefaultLayout);
 
     // Add overflow from children (unless we're multi-column, since in that case all our child overflow is clipped anyway).
     computeOverflow(oldClientAfterEdge);
 
     m_descendantsWithFloatsMarkedForLayout = false;
 }
 
 void RenderBlockFlow::determineLogicalLeftPositionForChild(RenderBox* child)
 {
     LayoutUnit startPosition = borderStart() + paddingStart();
-    LayoutUnit initialStartPosition = startPosition;
     if (style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
         startPosition -= verticalScrollbarWidth();
     LayoutUnit totalAvailableLogicalWidth = borderAndPaddingLogicalWidth() + availableLogicalWidth();
 
     LayoutUnit childMarginStart = marginStartForChild(child);
     LayoutUnit newPosition = startPosition + childMarginStart;
 
-    LayoutUnit positionToAvoidFloats;
-    if (child->avoidsFloats() && containsFloats())
-        positionToAvoidFloats = startOffsetForLine(logicalTopForChild(child), false, logicalHeightForChild(child));
-
     // If the child has an offset from the content edge to avoid floats then use that, otherwise let any negative
     // margin pull it back over the content edge or any positive margin push it out.
     // If the child is being centred then the margin calculated to do that has factored in any offset required to
     // avoid floats, so use it if necessary.
     if (style()->textAlign() == WEBKIT_CENTER || child->style()->marginStartUsing(style()).isAuto())
-        newPosition = std::max(newPosition, positionToAvoidFloats + childMarginStart);
-    else if (positionToAvoidFloats > initialStartPosition)
-        newPosition = std::max(newPosition, positionToAvoidFloats);
+        newPosition = std::max(newPosition, childMarginStart);

[esprehn, 2014/11/03 20:25:45]

I think you merged the wrong side of the branch here?

[ojan, 2014/11/03 20:27:06]

?

[ojan, 2014/11/03 20:28:10]

positionToAvoidFloats is always 0 since there are no floats.

[ojan, 2014/11/03 20:28:52]

Ah, this is much more clear if you see this in the side-by-side diff.

[esprehn, 2014/11/03 20:30:44]

Oh I see what happened here.

 
     setLogicalLeftForChild(child, style()->isLeftToRightDirection() ? newPosition : totalAvailableLogicalWidth - newPosition - logicalWidthForChild(child));
 }
 
 void RenderBlockFlow::setLogicalLeftForChild(RenderBox* child, LayoutUnit logicalLeft)
 {
     child->setX(logicalLeft);
 }
 
 void RenderBlockFlow::setLogicalTopForChild(RenderBox* child, LayoutUnit logicalTop)
 {
     child->setY(logicalTop);
 }
 
-void RenderBlockFlow::layoutBlockChild(RenderBox* child, MarginInfo& marginInfo, LayoutUnit& previousFloatLogicalBottom)
+void RenderBlockFlow::layoutBlockChild(RenderBox* child, MarginInfo& marginInfo)
 {
-    LayoutUnit oldPosMarginBefore = maxPositiveMarginBefore();
-    LayoutUnit oldNegMarginBefore = maxNegativeMarginBefore();
-
     // The child is a normal flow object. Compute the margins we will use for collapsing now.
     child->computeAndSetBlockDirectionMargins(this);
 
     // Try to guess our correct logical top position. In most cases this guess will
     // be correct. Only if we're wrong (when we compute the real logical top position)
     // will we have to potentially relayout.
-    LayoutUnit logicalTopEstimate = estimateLogicalTopPosition(child, marginInfo);
+    // Go ahead and position the child as though it didn't collapse with the top.
+    setLogicalTopForChild(child, estimateLogicalTopPosition(child, marginInfo));
 
-    // Cache our old rect so that we can dirty the proper paint invalidation rects if the child moves.
-    LayoutRect oldRect = child->frameRect();
-    LayoutUnit oldLogicalTop = logicalTopForChild(child);
-
-    // Go ahead and position the child as though it didn't collapse with the top.
-    setLogicalTopForChild(child, logicalTopEstimate);
-
-    RenderBlockFlow* childRenderBlockFlow = child->isRenderBlockFlow() ? toRenderBlockFlow(child) : 0;
-    bool markDescendantsWithFloats = false;
-    if (logicalTopEstimate != oldLogicalTop && childRenderBlockFlow && !childRenderBlockFlow->avoidsFloats() && childRenderBlockFlow->containsFloats()) {
-        markDescendantsWithFloats = true;
-    } else if (UNLIKELY(logicalTopEstimate.mightBeSaturated())) {
-        // logicalTopEstimate, returned by estimateLogicalTopPosition, might be saturated for
-        // very large elements. If it does the comparison with oldLogicalTop might yield a
-        // false negative as adding and removing margins, borders etc from a saturated number
-        // might yield incorrect results. If this is the case always mark for layout.
-        markDescendantsWithFloats = true;
-    } else if (!child->avoidsFloats() || child->shrinkToAvoidFloats()) {
-        // If an element might be affected by the presence of floats, then always mark it for
-        // layout.
-        LayoutUnit fb = std::max(previousFloatLogicalBottom, lowestFloatLogicalBottom());
-        if (fb > logicalTopEstimate)
-            markDescendantsWithFloats = true;
-    }
-
-    if (childRenderBlockFlow) {
-        if (markDescendantsWithFloats)
-            childRenderBlockFlow->markAllDescendantsWithFloatsForLayout();
-        previousFloatLogicalBottom = std::max(previousFloatLogicalBottom, oldLogicalTop + childRenderBlockFlow->lowestFloatLogicalBottom());
-    }
-
-    SubtreeLayoutScope layoutScope(*child);
-
-    bool childHadLayout = child->everHadLayout();
-    bool childNeededLayout = child->needsLayout();
-    if (childNeededLayout)
-        child->layout();
+    child->layoutIfNeeded();
 
     // Cache if we are at the top of the block right now.
     bool childIsSelfCollapsing = child->isSelfCollapsingBlock();
 
     // Now determine the correct ypos based off examination of collapsing margin
     // values.
-    LayoutUnit logicalTopBeforeClear = collapseMargins(child, marginInfo, childIsSelfCollapsing);
+    setLogicalTopForChild(child, collapseMargins(child, marginInfo, childIsSelfCollapsing));
 
-    // Now check for clear.
-    LayoutUnit logicalTopAfterClear = clearFloatsIfNeeded(child, marginInfo, oldPosMarginBefore, oldNegMarginBefore, logicalTopBeforeClear, childIsSelfCollapsing);
-
-    setLogicalTopForChild(child, logicalTopAfterClear);
-
-    // Now we have a final top position. See if it really does end up being different from our estimate.
-    // clearFloatsIfNeeded can also mark the child as needing a layout even though we didn't move. This happens
-    // when collapseMargins dynamically adds overhanging floats because of a child with negative margins.
-    if (logicalTopAfterClear != logicalTopEstimate || child->needsLayout()) {
-        SubtreeLayoutScope layoutScope(*child);
-        if (child->shrinkToAvoidFloats()) {
-            // The child's width depends on the line width.
-            // When the child shifts to clear an item, its width can
-            // change (because it has more available line width).
-            // So go ahead and mark the item as dirty.
-            layoutScope.setChildNeedsLayout(child);
-        }
-
-        if (childRenderBlockFlow && !childRenderBlockFlow->avoidsFloats() && childRenderBlockFlow->containsFloats())
-            childRenderBlockFlow->markAllDescendantsWithFloatsForLayout();
-
-        // Our guess was wrong. Make the child lay itself out again.
-        child->layoutIfNeeded();
-    }
+    // FIXME(sky): Is it still actually possible for the child to need layout here?
+    // This used to be needed for floats and/or margin collapsing.
+    child->layoutIfNeeded();
 
     // If we previously encountered a self-collapsing sibling of this child that had clearance then
     // we set this bit to ensure we would not collapse the child's margins, and those of any subsequent
     // self-collapsing siblings, with our parent. If this child is not self-collapsing then it can
     // collapse its margins with the parent so reset the bit.
     if (!marginInfo.canCollapseMarginAfterWithLastChild() && !childIsSelfCollapsing)
         marginInfo.setCanCollapseMarginAfterWithLastChild(true);
 
     // We are no longer at the top of the block if we encounter a non-empty child.
     // This has to be done after checking for clear, so that margins can be reset if a clear occurred.
     if (marginInfo.atBeforeSideOfBlock() && !childIsSelfCollapsing)
         marginInfo.setAtBeforeSideOfBlock(false);
 
     // Now place the child in the correct left position
     determineLogicalLeftPositionForChild(child);
 
-    LayoutSize childOffset = child->location() - oldRect.location();
-
     // Update our height now that the child has been placed in the correct position.
     setLogicalHeight(logicalHeight() + logicalHeightForChild(child));
     if (mustSeparateMarginAfterForChild(child)) {
         setLogicalHeight(logicalHeight() + marginAfterForChild(child));
         marginInfo.clearMargin();
     }
-    // If the child has overhanging floats that intrude into following siblings (or possibly out
-    // of this block), then the parent gets notified of the floats now.
-    if (childRenderBlockFlow)
-        addOverhangingFloats(childRenderBlockFlow, !childNeededLayout);
-
-    // If the child moved, we have to invalidate it's paint  as well as any floating/positioned
-    // descendants. An exception is if we need a layout. In this case, we know we're going to
-    // invalidate our paint (and the child) anyway.
-    bool didNotDoFullLayoutAndMoved = childHadLayout && !selfNeedsLayout() && (childOffset.width() || childOffset.height());
-    bool didNotLayoutAndNeedsPaintInvalidation = !childHadLayout && child->checkForPaintInvalidation();
-
-    if (didNotDoFullLayoutAndMoved || didNotLayoutAndNeedsPaintInvalidation)
-        child->invalidatePaintForOverhangingFloats(true);
-}
-
-void RenderBlockFlow::rebuildFloatsFromIntruding()
-{
-    // FIXME(sky): Remove this.
 }
 
 void RenderBlockFlow::layoutBlockChildren(bool relayoutChildren, SubtreeLayoutScope& layoutScope, LayoutUnit beforeEdge, LayoutUnit afterEdge)
 {
     dirtyForLayoutFromPercentageHeightDescendants(layoutScope);
 
     // The margin struct caches all our current margin collapsing state. The compact struct caches state when we encounter compacts,
     MarginInfo marginInfo(this, beforeEdge, afterEdge);
 
-    LayoutUnit previousFloatLogicalBottom = 0;
-
     RenderBox* next = firstChildBox();
     RenderBox* lastNormalFlowChild = 0;
 
     while (next) {
         RenderBox* child = next;
         next = child->nextSiblingBox();
 
         // FIXME: this should only be set from clearNeedsLayout crbug.com/361250
         child->setLayoutDidGetCalled(true);
 
         updateBlockChildDirtyBitsBeforeLayout(relayoutChildren, child);
 
         if (child->isOutOfFlowPositioned()) {
             child->containingBlock()->insertPositionedObject(child);
             adjustPositionedBlock(child, marginInfo);
             continue;
         }
 
         // Lay out the child.
-        layoutBlockChild(child, marginInfo, previousFloatLogicalBottom);
+        layoutBlockChild(child, marginInfo);
         lastNormalFlowChild = child;
     }
 
     // Now do the handling of the bottom of the block, adding in our bottom border/padding and
     // determining the correct collapsed bottom margin information.
     handleAfterSideOfBlock(lastNormalFlowChild, beforeEdge, afterEdge, marginInfo);
 }
 
 // Our MarginInfo state used when laying out block children.
 MarginInfo::MarginInfo(RenderBlockFlow* blockFlow, LayoutUnit beforeBorderPadding, LayoutUnit afterBorderPadding)
@@ skipping 186 matching lines @@
             marginInfo.setPositiveMargin(childMargins.positiveMarginAfter());
             marginInfo.setNegativeMargin(childMargins.negativeMarginAfter());
         } else {
             marginInfo.clearMargin();
         }
 
         if (marginInfo.margin())
             marginInfo.setHasMarginAfterQuirk(hasMarginAfterQuirk(child));
     }
 
-    if (previousBlockFlow) {
-        // If |child| is a self-collapsing block it may have collapsed into a previous sibling and although it hasn't reduced the height of the parent yet
-        // any floats from the parent will now overhang.
-        LayoutUnit oldLogicalHeight = logicalHeight();
-        setLogicalHeight(logicalTop);
-        if (!previousBlockFlow->avoidsFloats() && (previousBlockFlow->logicalTop() + previousBlockFlow->lowestFloatLogicalBottom()) > logicalTop)
-            addOverhangingFloats(previousBlockFlow, false);
-        setLogicalHeight(oldLogicalHeight);
-
-        // If |child|'s previous sibling is a self-collapsing block that cleared a float and margin collapsing resulted in |child| moving up
-        // into the margin area of the self-collapsing block then the float it clears is now intruding into |child|. Layout again so that we can look for
-        // floats in the parent that overhang |child|'s new logical top.
-        bool logicalTopIntrudesIntoFloat = clearanceForSelfCollapsingBlock > 0 && logicalTop < beforeCollapseLogicalTop;
-        if (logicalTopIntrudesIntoFloat && containsFloats() && !child->avoidsFloats() && lowestFloatLogicalBottom() > logicalTop)
-            child->setNeedsLayoutAndFullPaintInvalidation();
-    }
-
     return logicalTop;
 }
 
 void RenderBlockFlow::adjustPositionedBlock(RenderBox* child, const MarginInfo& marginInfo)
 {
     bool hasStaticBlockPosition = child->style()->hasStaticBlockPosition();
 
     LayoutUnit logicalTop = logicalHeight();
     updateStaticInlinePositionForChild(child, logicalTop);
 
     if (!marginInfo.canCollapseWithMarginBefore()) {
         // Positioned blocks don't collapse margins, so add the margin provided by
         // the container now. The child's own margin is added later when calculating its logical top.
         LayoutUnit collapsedBeforePos = marginInfo.positiveMargin();
         LayoutUnit collapsedBeforeNeg = marginInfo.negativeMargin();
         logicalTop += collapsedBeforePos - collapsedBeforeNeg;
     }
 
     RenderLayer* childLayer = child->layer();
     if (childLayer->staticBlockPosition() != logicalTop) {
         childLayer->setStaticBlockPosition(logicalTop);
         if (hasStaticBlockPosition)
             child->setChildNeedsLayout(MarkOnlyThis);
     }
 }
 
-LayoutUnit RenderBlockFlow::clearFloatsIfNeeded(RenderBox* child, MarginInfo& marginInfo, LayoutUnit oldTopPosMargin, LayoutUnit oldTopNegMargin, LayoutUnit yPos, bool childIsSelfCollapsing)
-{
-    LayoutUnit heightIncrease = getClearDelta(child, yPos);
-    if (!heightIncrease)
-        return yPos;
-
-    if (childIsSelfCollapsing) {
-        bool childDiscardMargin = mustDiscardMarginBeforeForChild(child) || mustDiscardMarginAfterForChild(child);
-
-        // For self-collapsing blocks that clear, they can still collapse their
-        // margins with following siblings. Reset the current margins to represent
-        // the self-collapsing block's margins only.
-        // If DISCARD is specified for -webkit-margin-collapse, reset the margin values.
-        RenderBlockFlow::MarginValues childMargins = marginValuesForChild(child);
-        if (!childDiscardMargin) {
-            marginInfo.setPositiveMargin(std::max(childMargins.positiveMarginBefore(), childMargins.positiveMarginAfter()));
-            marginInfo.setNegativeMargin(std::max(childMargins.negativeMarginBefore(), childMargins.negativeMarginAfter()));
-        } else {
-            marginInfo.clearMargin();
-        }
-        marginInfo.setDiscardMargin(childDiscardMargin);
-
-        // CSS2.1 states:
-        // "If the top and bottom margins of an element with clearance are adjoining, its margins collapse with
-        // the adjoining margins of following siblings but that resulting margin does not collapse with the bottom margin of the parent block."
-        // So the parent's bottom margin cannot collapse through this block or any subsequent self-collapsing blocks. Set a bit to ensure
-        // this happens; it will get reset if we encounter an in-flow sibling that is not self-collapsing.
-        marginInfo.setCanCollapseMarginAfterWithLastChild(false);
-
-        // For now set the border-top of |child| flush with the bottom border-edge of the float so it can layout any floating or positioned children of
-        // its own at the correct vertical position. If subsequent siblings attempt to collapse with |child|'s margins in |collapseMargins| we will
-        // adjust the height of the parent to |child|'s margin top (which if it is positive sits up 'inside' the float it's clearing) so that all three
-        // margins can collapse at the correct vertical position.
-        // Per CSS2.1 we need to ensure that any negative margin-top clears |child| beyond the bottom border-edge of the float so that the top border edge of the child
-        // (i.e. its clearance)  is at a position that satisfies the equation: "the amount of clearance is set so that clearance + margin-top = [height of float],
-        // i.e., clearance = [height of float] - margin-top".
-        setLogicalHeight(child->logicalTop() + childMargins.negativeMarginBefore());
-    } else {
-        // Increase our height by the amount we had to clear.
-        setLogicalHeight(logicalHeight() + heightIncrease);
-    }
-
-    if (marginInfo.canCollapseWithMarginBefore()) {
-        // We can no longer collapse with the top of the block since a clear
-        // occurred. The empty blocks collapse into the cleared block.
-        setMaxMarginBeforeValues(oldTopPosMargin, oldTopNegMargin);
-        marginInfo.setAtBeforeSideOfBlock(false);
-
-        // In case the child discarded the before margin of the block we need to reset the mustDiscardMarginBefore flag to the initial value.
-        setMustDiscardMarginBefore(style()->marginBeforeCollapse() == MDISCARD);
-    }
-
-    return yPos + heightIncrease;
-}
-
 void RenderBlockFlow::setCollapsedBottomMargin(const MarginInfo& marginInfo)
 {
     if (marginInfo.canCollapseWithMarginAfter() && !marginInfo.canCollapseWithMarginBefore()) {
         // Update the after side margin of the container to discard if the after margin of the last child also discards and we collapse with it.
         // Don't update the max margin values because we won't need them anyway.
         if (marginInfo.discardMargin()) {
             setMustDiscardMarginAfter();
             return;
         }
 
@@ skipping 88 matching lines @@
             positiveMarginBefore = std::max(positiveMarginBefore, marginValues.positiveMarginBefore());
             negativeMarginBefore = std::max(negativeMarginBefore, marginValues.negativeMarginBefore());
             discardMarginBefore = mustDiscardMarginBeforeForChild(child);
         }
 
         // Collapse the result with our current margins.
         if (!discardMarginBefore)
             logicalTopEstimate += std::max(marginInfo.positiveMargin(), positiveMarginBefore) - std::max(marginInfo.negativeMargin(), negativeMarginBefore);
     }
 
-    logicalTopEstimate += getClearDelta(child, logicalTopEstimate);
     return logicalTopEstimate;
 }
 
 LayoutUnit RenderBlockFlow::marginOffsetForSelfCollapsingBlock()
 {
+    // FIXME(sky): Remove
     ASSERT(isSelfCollapsingBlock());
-    RenderBlockFlow* parentBlock = toRenderBlockFlow(parent());
-    if (parentBlock && style()->clear() && parentBlock->getClearDelta(this, logicalHeight()))
-        return marginValuesForChild(this).positiveMarginBefore();
     return LayoutUnit();
 }
 
-void RenderBlockFlow::adjustFloatingBlock(const MarginInfo& marginInfo)
-{
-    // The float should be positioned taking into account the bottom margin
-    // of the previous flow. We add that margin into the height, get the
-    // float positioned properly, and then subtract the margin out of the
-    // height again. In the case of self-collapsing blocks, we always just
-    // use the top margins, since the self-collapsing block collapsed its
-    // own bottom margin into its top margin.
-    //
-    // Note also that the previous flow may collapse its margin into the top of
-    // our block. If this is the case, then we do not add the margin in to our
-    // height when computing the position of the float. This condition can be tested
-    // for by simply calling canCollapseWithMarginBefore. See
-    // http://www.hixie.ch/tests/adhoc/css/box/block/margin-collapse/046.html for
-    // an example of this scenario.
-    LayoutUnit marginOffset = marginInfo.canCollapseWithMarginBefore() ? LayoutUnit() : marginInfo.margin();
-    setLogicalHeight(logicalHeight() + marginOffset);
-    positionNewFloats();
-    setLogicalHeight(logicalHeight() - marginOffset);
-}
-
 void RenderBlockFlow::handleAfterSideOfBlock(RenderBox* lastChild, LayoutUnit beforeSide, LayoutUnit afterSide, MarginInfo& marginInfo)
 {
     marginInfo.setAtAfterSideOfBlock(true);
 
     // If our last child was a self-collapsing block with clearance then our logical height is flush with the
     // bottom edge of the float that the child clears. The correct vertical position for the margin-collapsing we want
     // to perform now is at the child's margin-top - so adjust our height to that position.
     if (lastChild && lastChild->isRenderBlockFlow() && lastChild->isSelfCollapsingBlock())
         setLogicalHeight(logicalHeight() - toRenderBlockFlow(lastChild)->marginOffsetForSelfCollapsingBlock());
 
@@ skipping 98 matching lines @@
     return childStyle->marginBeforeCollapse() == MSEPARATE;
 }
 
 bool RenderBlockFlow::mustSeparateMarginAfterForChild(const RenderBox* child) const
 {
     ASSERT(!child->selfNeedsLayout());
     const RenderStyle* childStyle = child->style();
     return childStyle->marginAfterCollapse() == MSEPARATE;
 }
 
-void RenderBlockFlow::addOverflowFromFloats()
-{
-    // FIXME(sky): Remove this.
-}
-
-void RenderBlockFlow::computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats)
-{
-    RenderBlock::computeOverflow(oldClientAfterEdge, recomputeFloats);
-    if (recomputeFloats || createsBlockFormattingContext() || hasSelfPaintingLayer())
-        addOverflowFromFloats();
-}
-
 RootInlineBox* RenderBlockFlow::createAndAppendRootInlineBox()
 {
     RootInlineBox* rootBox = createRootInlineBox();
     m_lineBoxes.appendLineBox(rootBox);
 
     return rootBox;
 }
 
 void RenderBlockFlow::deleteLineBoxTree()
 {
     m_lineBoxes.deleteLineBoxTree();
 }
 
-void RenderBlockFlow::markAllDescendantsWithFloatsForLayout(RenderBox* floatToRemove, bool inLayout)
-{
-    // FIXME(sky): Remove this.
-}
-
-void RenderBlockFlow::markSiblingsWithFloatsForLayout(RenderBox* floatToRemove)
-{
-    // FIXME(sky): Remove this.
-}
-
-LayoutUnit RenderBlockFlow::getClearDelta(RenderBox* child, LayoutUnit logicalTop)
-{
-    // FIXME(sky): Remove this.
-    return 0;
-}
-
-void RenderBlockFlow::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
-{
-    RenderStyle* oldStyle = style();
-    s_canPropagateFloatIntoSibling = oldStyle ? !isFloatingOrOutOfFlowPositioned() && !avoidsFloats() : false;
-    if (oldStyle && parent() && diff.needsFullLayout() && oldStyle->position() != newStyle.position()
-        && containsFloats() && !isFloating() && !isOutOfFlowPositioned() && newStyle.hasOutOfFlowPosition())
-            markAllDescendantsWithFloatsForLayout();
-
-    RenderBlock::styleWillChange(diff, newStyle);
-}
-
-void RenderBlockFlow::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
-{
-    // FIXME(sky): Remove this.
-    RenderBlock::styleDidChange(diff, oldStyle);
-}
-
 void RenderBlockFlow::updateStaticInlinePositionForChild(RenderBox* child, LayoutUnit logicalTop)
 {
     if (child->style()->isOriginalDisplayInlineType())
         setStaticInlinePositionForChild(child, startAlignedOffsetForLine(logicalTop, false));
     else
         setStaticInlinePositionForChild(child, startOffsetForContent());
 }
 
 void RenderBlockFlow::setStaticInlinePositionForChild(RenderBox* child, LayoutUnit inlinePosition)
 {
     child->layer()->setStaticInlinePosition(inlinePosition);
 }
 
 void RenderBlockFlow::addChild(RenderObject* newChild, RenderObject* beforeChild)
 {
     RenderBlock::addChild(newChild, beforeChild);
 }
 
 void RenderBlockFlow::moveAllChildrenIncludingFloatsTo(RenderBlock* toBlock, bool fullRemoveInsert)
 {
     // FIXME(sky): Merge this into callers.
     RenderBlockFlow* toBlockFlow = toRenderBlockFlow(toBlock);
     moveAllChildrenTo(toBlockFlow, fullRemoveInsert);
 }
 
-void RenderBlockFlow::invalidatePaintForOverhangingFloats(bool paintAllDescendants)
-{
-    // FIXME(sky): Remove this.
-}
-
 void RenderBlockFlow::invalidatePaintForOverflow()
 {
     // FIXME: We could tighten up the left and right invalidation points if we let layoutInlineChildren fill them in based off the particular lines
     // it had to lay out. We wouldn't need the hasOverflowClip() hack in that case either.
     LayoutUnit paintInvalidationLogicalLeft = logicalLeftVisualOverflow();
     LayoutUnit paintInvalidationLogicalRight = logicalRightVisualOverflow();
     if (hasOverflowClip()) {
         // If we have clipped overflow, we should use layout overflow as well, since visual overflow from lines didn't propagate to our block's overflow.
         // Note the old code did this as well but even for overflow:visible. The addition of hasOverflowClip() at least tightens up the hack a bit.
         // layoutInlineChildren should be patched to compute the entire paint invalidation rect.
@@ skipping 21 matching lines @@
 
     m_paintInvalidationLogicalTop = 0;
     m_paintInvalidationLogicalBottom = 0;
 }
 
 void RenderBlockFlow::paintFloats(PaintInfo& paintInfo, const LayoutPoint& paintOffset, bool preservePhase)
 {
     // FIXME(sky): Remove this.
 }
 
-void RenderBlockFlow::clearFloats(EClear clear)
-{
-    // FIXME(sky): Remove this.
-}
-
 LayoutUnit RenderBlockFlow::logicalLeftOffsetForPositioningFloat(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining) const
 {
     // FIXME(sky): Remove this.
     LayoutUnit offset = fixedOffset;
     return adjustLogicalLeftOffsetForLine(offset, applyTextIndent);
 }
 
 LayoutUnit RenderBlockFlow::logicalRightOffsetForPositioningFloat(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining) const
 {
     // FIXME(sky): Remove this.
@@ skipping 14 matching lines @@
 LayoutUnit RenderBlockFlow::adjustLogicalRightOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const
 {
     LayoutUnit right = offsetFromFloats;
 
     if (applyTextIndent && !style()->isLeftToRightDirection())
         right -= textIndentOffset();
 
     return right;
 }
 
-LayoutPoint RenderBlockFlow::computeLogicalLocationForFloat(const FloatingObject* floatingObject, LayoutUnit logicalTopOffset) const
-{
-    // FIXME(sky): Remove this.
-    return LayoutPoint();
-}
-
-bool RenderBlockFlow::positionNewFloats()
-{
-    // FIXME(sky): Remove this.
-    return false;
-}
-
-bool RenderBlockFlow::hasOverhangingFloat(RenderBox* renderer)
-{
-    // FIXME(sky): Remove this.
-    return false;
-}
-
-void RenderBlockFlow::addIntrudingFloats(RenderBlockFlow* prev, LayoutUnit logicalLeftOffset, LayoutUnit logicalTopOffset)
-{
-    // FIXME(sky): Remove this.
-}
-
-void RenderBlockFlow::addOverhangingFloats(RenderBlockFlow* child, bool makeChildPaintOtherFloats)
-{
-    // FIXME(sky): Remove this.
-}
-
 bool RenderBlockFlow::hitTestFloats(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset)
 {
     // FIXME(sky): Remove this.
     return false;
 }
 
 LayoutUnit RenderBlockFlow::logicalLeftFloatOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, LayoutUnit logicalHeight) const
 {
     // FIXME(sky): remove this.
     return fixedOffset;
@@ skipping 101 matching lines @@
 RenderBlockFlow::RenderBlockFlowRareData& RenderBlockFlow::ensureRareData()
 {
     if (m_rareData)
         return *m_rareData;
 
     m_rareData = adoptPtr(new RenderBlockFlowRareData(this));
     return *m_rareData;
 }
 
 } // namespace blink