[New Multicolumn] Actual support for layout of column-span:all.

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 526 matching lines @@
 
 void RenderBlockFlow::setLogicalTopForChild(RenderBox* child, LayoutUnit logicalTop)
 {
     if (isHorizontalWritingMode()) {
         child->setY(logicalTop);
     } else {
         child->setX(logicalTop);
     }
 }
 
+class ColumnSpannerLayoutScope {
+public:
+    ColumnSpannerLayoutScope()
+        : m_spanner(0) { }
+
+    ~ColumnSpannerLayoutScope()
+    {
+        if (!m_spanner)
+            return;
+        m_spanner->flowThreadContainingBlock()->leaveColumnSpannerAfterLayout(m_spanner, m_spanner->containingBlock()->logicalHeight());
+    }
+
+    LayoutUnit enterSpanner(RenderBox* spanner, SubtreeLayoutScope& layoutScope)
+    {
+        ASSERT(!m_spanner);
+        m_spanner = spanner;
+        return m_spanner->flowThreadContainingBlock()->enterColumnSpannerBeforeLayout(m_spanner, m_spanner->containingBlock()->logicalHeight(), layoutScope);
+    }
+
+private:
+    RenderBox* m_spanner;
+};
+
 void RenderBlockFlow::layoutBlockChild(RenderBox* child, MarginInfo& marginInfo, LayoutUnit& previousFloatLogicalBottom)
 {
     LayoutUnit oldPosMarginBefore = maxPositiveMarginBefore();
     LayoutUnit oldNegMarginBefore = maxNegativeMarginBefore();
 
+    SubtreeLayoutScope layoutScope(*child);
+
+    ColumnSpannerLayoutScope columnSpannerLayoutScope;
+    if (child->isColumnSpanAll()) {
+        LayoutUnit adjustment = columnSpannerLayoutScope.enterSpanner(child, layoutScope);
+        // A spanner needs to start at an exact column boundary inside the flow thread, so that it
+        // doesn't bleed into a preceding column. That's what the adjustment is about.
+        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);
 
     // Cache our old rect so that we can dirty the proper paint invalidation rects if the child moves.
@@ skipping 21 matching lines @@
             markDescendantsWithFloats = true;
     }
 
     if (childRenderBlockFlow) {
         if (markDescendantsWithFloats)
             childRenderBlockFlow->markAllDescendantsWithFloatsForLayout();
         if (!child->isWritingModeRoot())
             previousFloatLogicalBottom = std::max(previousFloatLogicalBottom, oldLogicalTop + childRenderBlockFlow->lowestFloatLogicalBottom());
     }
 
-    SubtreeLayoutScope layoutScope(*child);
     if (!child->needsLayout())
         child->markForPaginationRelayoutIfNeeded(layoutScope);
 
     bool childNeededLayout = child->needsLayout();
     if (childNeededLayout)
         child->layout();
 
     // Cache if we are at the top of the block right now.
     bool atBeforeSideOfBlock = marginInfo.atBeforeSideOfBlock();
     bool childIsSelfCollapsing = child->isSelfCollapsingBlock();
@@ skipping 684 matching lines @@
             marginInfo.clearMargin();
         }
 
         if (marginInfo.margin())
             marginInfo.setHasMarginAfterQuirk(hasMarginAfterQuirk(child));
     }
 
     // If margins would pull us past the top of the next page, then we need to pull back and pretend like the margins
     // collapsed into the page edge.
     LayoutState* layoutState = view()->layoutState();
-    if (layoutState->isPaginated() && layoutState->pageLogicalHeight() && logicalTop > beforeCollapseLogicalTop) {
+    if (layoutState->isPaginated() && layoutState->pageLogicalHeight() && logicalTop > beforeCollapseLogicalTop && !child->isColumnSpanAll()) {

[Julien - ping for review, 2014/11/17 23:47:11]

It seems like we should just make column spanning items create new stacking
contexts (see example 27) so that it disable margin collapsing in some context.
This is done by updating RenderBlockFlow::createsNewFormattingContext().

[mstensho (USE GERRIT), 2014/11/18 13:29:26]

They already do create a new block formatting context (and I did update that
method), but doing that doesn't prevent margins of the BFC block from collapsing
with the surrounding margins. It only prevents margins of the BFC's children
from collapsing with BFC's own margins (and the BFC's surroundings).

What's example 27?

And "stacking context" was a typo, no?

[Julien - ping for review, 2014/11/19 17:54:34]

I missed that you actually changed the function in this patch. What I meant to
write (but missed the intent of the code) is that we should not get into the
collapsing margin logic if we shouldn't collapse them. I don't have a good
suggestion unfortunately as I don't know the collapsing margin code very well so
I could be missing something.
Sorry, I meant example 27 of the multi-column specification (scroll down a bit
from http://dev.w3.org/csswg/css-multicol/#column-span)
Yeah, I meant block formatting context.

[mstensho (USE GERRIT), 2014/11/21 15:39:24]

This code here is about the top margin. Being a BFC here or not doesn't really
matter. A new BFC also lives in a BFC established by some ancestor, and it will
collapse with its previous siblings and parents.

<div style="margin-bottom:100px;">xxx</div><div style="overflow:hidden;
margin-top:100px;"></div>

The margin between the two DIVs here will be 100px, even if the latter is a BFC.

But we digress: This isn't really about regular margin collapsing, but rather
about eating top margins of elements that end up as the first element in a
column. [1]

But hey, I just realized that this change isn't needed by any of the current
tests, so I'll just back it out for now. I will probably have to reintroduce
this later, since I have some more tests (and code) in the oven.

[1] http://dev.w3.org/csswg/css-break/#break-margins

         LayoutUnit oldLogicalTop = logicalTop;
         logicalTop = std::min(logicalTop, nextPageLogicalTop(beforeCollapseLogicalTop));
         setLogicalHeight(logicalHeight() + (logicalTop - oldLogicalTop));
     }
 
     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);
@@ skipping 195 matching lines @@
         }
 
         // Collapse the result with our current margins.
         if (!discardMarginBefore)
             logicalTopEstimate += std::max(marginInfo.positiveMargin(), positiveMarginBefore) - std::max(marginInfo.negativeMargin(), negativeMarginBefore);
     }
 
     // Adjust logicalTopEstimate down to the next page if the margins are so large that we don't fit on the current
     // page.
     LayoutState* layoutState = view()->layoutState();
-    if (layoutState->isPaginated() && layoutState->pageLogicalHeight() && logicalTopEstimate > logicalHeight())
+    if (layoutState->isPaginated() && layoutState->pageLogicalHeight() && logicalTopEstimate > logicalHeight() && !child->isColumnSpanAll())

[mstensho (USE GERRIT), 2014/11/21 15:39:24]

I'll remove this for now. No test covers it. See previous comment.

         logicalTopEstimate = std::min(logicalTopEstimate, nextPageLogicalTop(logicalHeight()));
 
     logicalTopEstimate += getClearDelta(child, logicalTopEstimate);
 
     estimateWithoutPagination = logicalTopEstimate;
 
     if (layoutState->isPaginated()) {
         // If the object has a page or column break value of "before", then we should shift to the top of the next page.
         logicalTopEstimate = applyBeforeBreak(child, logicalTopEstimate);
 
@@ skipping 1319 matching lines @@
     FrameView* frameView = document().view();
     LayoutUnit top = (style()->position() == FixedPosition) ? 0 : frameView->scrollOffset().height();
     int visibleHeight = frameView->visibleContentRect(IncludeScrollbars).height();
     if (height() < visibleHeight)
         top += (visibleHeight - height()) / 2;
     setY(top);
     dialog->setCentered(top);
 }
 
 } // namespace blink