*** DO NOT LAND *** Implement column-span:all without reparenting renderers. Work in progress.

Source/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 530 matching lines @@
         child->setY(logicalTop);
     } else {
         child->setX(logicalTop);
     }
 }
 
 void RenderBlockFlow::layoutBlockChild(RenderBox* child, MarginInfo& marginInfo, LayoutUnit& previousFloatLogicalBottom)
 {
     LayoutUnit oldPosMarginBefore = maxPositiveMarginBefore();
     LayoutUnit oldNegMarginBefore = maxNegativeMarginBefore();
+    bool isColumnSpanner = child->isColumnSpanAll();
+
+    if (isColumnSpanner) {
+        // Margins of a column spanner cannot collapse with anything.
+        setLogicalHeight(logicalHeight() + marginInfo.margin());
+        marginInfo.clearMargin();
+        LayoutUnit adjustment = flowThreadContainingBlock()->enterColumnSpanner(child, logicalHeight());
+        setLogicalHeight(logicalHeight() + adjustment);
+    }
 
     // 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 estimateWithoutPagination;
     LayoutUnit logicalTopEstimate = estimateLogicalTopPosition(child, marginInfo, estimateWithoutPagination);
 
-    bool isColumnSpanner = child->isColumnSpanAll();
-    if (isColumnSpanner) {
-        LayoutUnit margin = child->marginBefore();
-        logicalTopEstimate -= margin;
-        flowThreadContainingBlock()->enterColumnSpanner(child, logicalTopEstimate);
-        logicalTopEstimate += margin;
-    }
-
     // 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()) {
@@ skipping 147 matching lines @@
 
         // Our guess was wrong. Make the child lay itself out again.
         child->layoutIfNeeded();
     }
 
     LayoutUnit oldTop = logicalTopAfterClear;
 
     // If the object has a page or column break value of "before", then we should shift to the top of the next page.
     LayoutUnit result = applyBeforeBreak(child, logicalTopAfterClear);
 
-    if (child->isColumnSpanAll())
-        result += flowThreadContainingBlock()->spannerLogicalTopAdjustment(child, result - child->marginBefore());
-
     // For replaced elements and scrolled elements, we want to shift them to the next page if they don't fit on the current one.
     LayoutUnit logicalTopBeforeUnsplittableAdjustment = result;
     LayoutUnit logicalTopAfterUnsplittableAdjustment = adjustForUnsplittableChild(child, result);
 
     LayoutUnit paginationStrut = 0;
     LayoutUnit unsplittableAdjustmentDelta = logicalTopAfterUnsplittableAdjustment - logicalTopBeforeUnsplittableAdjustment;
     LayoutUnit childLogicalHeight = child->logicalHeight();
     if (unsplittableAdjustmentDelta) {
         setPageBreak(result, childLogicalHeight - unsplittableAdjustmentDelta);
         paginationStrut = unsplittableAdjustmentDelta;
@@ skipping 427 matching lines @@
     // top to get new posTop and negTop values.
     if (childIsSelfCollapsing) {
         posTop = std::max(posTop, childMargins.positiveMarginAfter());
         negTop = std::max(negTop, childMargins.negativeMarginAfter());
     }
 
     // See if the top margin is quirky. We only care if this child has
     // margins that will collapse with us.
     bool topQuirk = hasMarginBeforeQuirk(child);
 
-    if (marginInfo.canCollapseWithMarginBefore() && !mustSeparateMarginBeforeForChild(child)) {
+    if (marginInfo.canCollapseWithMarginBefore()) {
         if (!childDiscardMarginBefore && !marginInfo.discardMargin()) {
             // This child is collapsing with the top of the
             // block. If it has larger margin values, then we need to update
             // our own maximal values.
             if (!document().inQuirksMode() || !marginInfo.quirkContainer() || !topQuirk)
                 setMaxMarginBeforeValues(std::max(posTop, maxPositiveMarginBefore()), std::max(negTop, maxNegativeMarginBefore()));
 
             // The minute any of the margins involved isn't a quirk, don't
             // collapse it away, even if the margin is smaller (www.webreference.com
             // has an example of this, a <dt> with 0.8em author-specified inside
@@ skipping 264 matching lines @@
     RenderBox* grandchildBox = childBlockFlow->firstChildBox();
     for ( ; grandchildBox; grandchildBox = grandchildBox->nextSiblingBox()) {
         if (!grandchildBox->isFloatingOrOutOfFlowPositioned())
             break;
     }
 
     // Give up if there is clearance on the box, since it probably won't collapse into us.
     if (!grandchildBox || grandchildBox->style()->clear() != CNONE)
         return;
 
-    if (childBlockFlow->mustSeparateMarginBeforeForChild(grandchildBox))
-        return;
-
     // Make sure to update the block margins now for the grandchild box so that we're looking at current values.
     if (grandchildBox->needsLayout()) {
         grandchildBox->computeAndSetBlockDirectionMargins(this);
         if (grandchildBox->isRenderBlock()) {
             RenderBlock* grandchildBlock = toRenderBlock(grandchildBox);
             grandchildBlock->setHasMarginBeforeQuirk(grandchildBox->style()->hasMarginBeforeQuirk());
             grandchildBlock->setHasMarginAfterQuirk(grandchildBox->style()->hasMarginAfterQuirk());
         }
     }
 
     // Collapse the margin of the grandchild box with our own to produce an estimate.
     childBlockFlow->marginBeforeEstimateForChild(grandchildBox, positiveMarginBefore, negativeMarginBefore, discardMarginBefore);
 }
 
 LayoutUnit RenderBlockFlow::estimateLogicalTopPosition(RenderBox* child, const MarginInfo& marginInfo, LayoutUnit& estimateWithoutPagination)
 {
     // FIXME: We need to eliminate the estimation of vertical position, because when it's wrong we sometimes trigger a pathological
     // relayout if there are intruding floats.
     LayoutUnit logicalTopEstimate = logicalHeight();
-    if (!marginInfo.canCollapseWithMarginBefore() || mustSeparateMarginBeforeForChild(child)) {
+    if (!marginInfo.canCollapseWithMarginBefore()) {
         LayoutUnit positiveMarginBefore = 0;
         LayoutUnit negativeMarginBefore = 0;
         bool discardMarginBefore = false;
         if (child->selfNeedsLayout()) {
             // Try to do a basic estimation of how the collapse is going to go.
             marginBeforeEstimateForChild(child, positiveMarginBefore, negativeMarginBefore, discardMarginBefore);
         } else {
             // Use the cached collapsed margin values from a previous layout. Most of the time they
             // will be right.
             RenderBlockFlow::MarginValues marginValues = marginValuesForChild(child);
@@ skipping 174 matching lines @@
         if (pos == RenderBlockFlowRareData::positiveMarginAfterDefault(this) && neg == RenderBlockFlowRareData::negativeMarginAfterDefault(this))
             return;
         m_rareData = adoptPtrWillBeNoop(new RenderBlockFlowRareData(this));
     }
     m_rareData->m_margins.setPositiveMarginAfter(pos);
     m_rareData->m_margins.setNegativeMarginAfter(neg);
 }
 
 bool RenderBlockFlow::mustSeparateMarginBeforeForChild(const RenderBox* child) const
 {
-    if (child->isColumnSpanAll())
-        return true;
+    ASSERT(!child->selfNeedsLayout());
     const RenderStyle* childStyle = child->style();
     if (!child->isWritingModeRoot())
         return childStyle->marginBeforeCollapse() == MSEPARATE;
     if (child->isHorizontalWritingMode() == isHorizontalWritingMode())
         return childStyle->marginAfterCollapse() == MSEPARATE;
 
     // FIXME: See |mustDiscardMarginBeforeForChild| above.
     return false;
 }
 
 bool RenderBlockFlow::mustSeparateMarginAfterForChild(const RenderBox* child) const
 {
-    if (child->isColumnSpanAll())
-        return true;
+    ASSERT(!child->selfNeedsLayout());
     const RenderStyle* childStyle = child->style();
     if (!child->isWritingModeRoot())
         return childStyle->marginAfterCollapse() == MSEPARATE;
     if (child->isHorizontalWritingMode() == isHorizontalWritingMode())
         return childStyle->marginBeforeCollapse() == MSEPARATE;
 
     // FIXME: See |mustDiscardMarginBeforeForChild| above.
     return false;
 }
 
@@ skipping 1210 matching lines @@
 RenderBlockFlow::RenderBlockFlowRareData& RenderBlockFlow::ensureRareData()
 {
     if (m_rareData)
         return *m_rareData;
 
     m_rareData = adoptPtrWillBeNoop(new RenderBlockFlowRareData(this));
     return *m_rareData;
 }
 
 } // namespace blink