[New Multicolumn] Add support for column-span:all

Source/core/rendering/RenderMultiColumnSet.cpp

 /*
  * Copyright (C) 2012 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 11 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/rendering/RenderMultiColumnSet.h"
 
 #include "core/rendering/PaintInfo.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderMultiColumnFlowThread.h"
+#include "core/rendering/RenderMultiColumnSpannerPlaceholder.h"
 
 using namespace std;
 
 namespace WebCore {
 
 RenderMultiColumnSet::RenderMultiColumnSet(RenderFlowThread* flowThread)
     : RenderRegion(0, flowThread)
     , m_columnHeight(0)
     , m_maxColumnHeight(RenderFlowThread::maxLogicalHeight())
     , m_minSpaceShortage(RenderFlowThread::maxLogicalHeight())
@@ skipping 21 matching lines @@
 
 RenderMultiColumnSet* RenderMultiColumnSet::previousSiblingMultiColumnSet() const
 {
     for (RenderObject* sibling = previousSibling(); sibling; sibling = sibling->previousSibling()) {
         if (sibling->isRenderMultiColumnSet())
             return toRenderMultiColumnSet(sibling);
     }
     return 0;
 }
 
+RenderObject* RenderMultiColumnSet::firstRendererInFlowThread() const
+{
+    if (RenderBox* sibling = RenderMultiColumnFlowThread::previousColumnSetOrSpannerSiblingOf(this)) {
+        // Adjacent sets should not occur. Currently we would have no way of figuring out what each
+        // of them contains then.
+        ASSERT(!sibling->isRenderMultiColumnSet());
+        RenderMultiColumnSpannerPlaceholder* placeholder = multiColumnFlowThread()->findColumnSpannerPlaceholder(sibling);

[rune, 2014/07/01 08:41:38]

Perhaps add an ASSERT(placeholder) as well?

[mstensho (USE GERRIT), 2014/08/26 09:43:58]

Is it really necessary? It's gonna crash if it's NULL anyway.

[rune, 2014/08/27 07:00:01]

It adds the information that it's not missing a null-check, but it's not
important to me.

+        return placeholder->nextInPreOrderAfterChildren();
+    }
+    return flowThread()->firstChild();
+}
+
+RenderObject* RenderMultiColumnSet::lastRendererInFlowThread() const
+{
+    if (RenderBox* sibling = RenderMultiColumnFlowThread::nextColumnSetOrSpannerSiblingOf(this)) {
+        // Adjacent sets should not occur. Currently we would have no way of figuring out what each
+        // of them contains then.
+        ASSERT(!sibling->isRenderMultiColumnSet());
+        RenderMultiColumnSpannerPlaceholder* placeholder = multiColumnFlowThread()->findColumnSpannerPlaceholder(sibling);
+        return placeholder->previousInPreOrder();
+    }
+    return flowThread()->lastLeafChild();
+}
+
+static bool precedesRenderer(RenderObject* renderer, RenderObject* boundary)
+{
+    for (; renderer; renderer = renderer->nextInPreOrder()) {
+        if (renderer == boundary)
+            return true;
+    }
+    return false;
+}
+
+bool RenderMultiColumnSet::renders(RenderObject* renderer) const
+{
+    if (!previousSiblingMultiColumnSet() && !nextSiblingMultiColumnSet()) {
+        // There is only one set. This is easy, then.
+        return renderer->isDescendantOf(m_flowThread);
+    }
+
+    RenderObject* firstRenderer = firstRendererInFlowThread();
+    RenderObject* lastRenderer = lastRendererInFlowThread();
+    ASSERT(firstRenderer);
+    ASSERT(lastRenderer);
+
+    // This is SLOW! But luckily very uncommon.

[rune, 2014/07/01 08:41:38]

Perhaps note in which cases it happens. Is it when the column-span property
changes on a block inside a multicolset, or an element with a column-span
renderer changes display type?

[mstensho (USE GERRIT), 2014/08/26 09:43:58]

Done.

[rune, 2014/08/27 08:17:38]

Acknowledged.

+    return precedesRenderer(firstRenderer, renderer) && precedesRenderer(renderer, lastRenderer);

[rune, 2014/07/01 08:41:38]

Do you need to check both? From where you call renders() you go through the
multicolumn sets from first to last. Would it be enough to call
precedesRenderer(renderer, lastRenderer), or is it possible at this point we're
looking for a spanner inside a spanner?

If it's the case that we can be looking at a RenderObject inside a spanner here,
can't the loop in findSetRendering be terminated if renderer precedes
firstRenderer?

[mstensho (USE GERRIT), 2014/08/26 09:43:58]

Done.

We don't look inside spanners here, so no need to optimize for it.

[rune, 2014/08/27 08:17:38]

I see that this code has been transformed in an optimization patch set. It would
have been better to take that change in a separate CL with a proper description.

[mstensho (USE GERRIT), 2014/08/27 08:24:05]

This code is new in this CL and an issue was raised against it, so I fixed it. I
must have misunderstood what you meant now. Please clarify.

[rune, 2014/08/27 08:36:31]

It such a long time since I reviewed this as well. I thought you could just
remove the first precedesRenderer() call, but perhaps that's what you've done in
practice, I need to take another look.

[mstensho (USE GERRIT), 2014/08/27 08:47:02]

That's what I did in practice. But I lumped it all together in the calller,
since, by removing the second call, the renders() method could no longer really
be used to figure out if a renderer belongs to a set. You'd have to make ugly
assumptions about the caller iterating through all sets in a specific order.

[rune, 2014/08/27 10:22:27]

Acknowledged.

+}
+
+void RenderMultiColumnSet::setLogicalTopInFlowThread(LayoutUnit logicalTop)
+{
+    LayoutRect rect = flowThreadPortionRect();
+    if (isHorizontalWritingMode())
+        rect.setY(logicalTop);
+    else
+        rect.setX(logicalTop);
+    setFlowThreadPortionRect(rect);
+}
+
+void RenderMultiColumnSet::setLogicalBottomInFlowThread(LayoutUnit logicalBottom)
+{
+    LayoutRect rect = flowThreadPortionRect();
+    if (isHorizontalWritingMode())
+        rect.shiftMaxYEdgeTo(logicalBottom);
+    else
+        rect.shiftMaxXEdgeTo(logicalBottom);
+    setFlowThreadPortionRect(rect);
+}
+
+bool RenderMultiColumnSet::heightIsAuto() const
+{
+    RenderMultiColumnFlowThread* flowThread = multiColumnFlowThread();
+    if (!flowThread->isRenderPagedFlowThread()) {
+        if (RenderBox* next = RenderMultiColumnFlowThread::nextColumnSetOrSpannerSiblingOf(this)) {
+            if (!next->isRenderMultiColumnSet()) {
+                // If we're followed by a spanner, we need to balance.
+                ASSERT(flowThread->findColumnSpannerPlaceholder(next));
+                return true;
+            }
+        }
+        if (multiColumnBlockFlow()->style()->columnFill() == ColumnFillBalance)
+            return true;
+    }
+    return !flowThread->columnHeightAvailable();
+}
+
 LayoutSize RenderMultiColumnSet::flowThreadTranslationAtOffset(LayoutUnit blockOffset) const
 {
     unsigned columnIndex = columnIndexAtOffset(blockOffset);
     LayoutRect portionRect(flowThreadPortionRectAt(columnIndex));
     flipForWritingMode(portionRect);
     LayoutRect columnRect(columnRectAt(columnIndex));
     flipForWritingMode(columnRect);
     return contentBoxRect().location() + columnRect.location() - portionRect.location();
 }
 
 LayoutUnit RenderMultiColumnSet::heightAdjustedForSetOffset(LayoutUnit height) const
 {
     // Adjust for the top offset within the content box of the multicol container (containing
     // block), unless this is the first set. We know that the top offset for the first set will be
     // zero, but if the multicol container has non-zero top border or padding, the set's top offset
     // (initially being 0 and relative to the border box) will be negative until it has been laid
     // out. Had we used this bogus offset, we would calculate the wrong height, and risk performing
     // a wasted layout iteration. Of course all other sets (if any) have this problem in the first
     // layout pass too, but there's really nothing we can do there until the flow thread has been
     // laid out anyway.
-    if (previousSiblingMultiColumnSet()) {
+    if (RenderMultiColumnFlowThread::previousColumnSetOrSpannerSiblingOf(this)) {
         RenderBlockFlow* multicolBlock = multiColumnBlockFlow();
         LayoutUnit contentLogicalTop = logicalTop() - multicolBlock->borderAndPaddingBefore();
         height -= contentLogicalTop;
     }
     return max(height, LayoutUnit(1)); // Let's avoid zero height, as that would probably cause an infinite amount of columns to be created.
 }
 
 LayoutUnit RenderMultiColumnSet::pageLogicalTopForOffset(LayoutUnit offset) const
 {
     unsigned columnIndex = columnIndexAtOffset(offset, AssumeNewColumns);
@@ skipping 82 matching lines @@
     ASSERT(m_minSpaceShortage > 0); // We should never _shrink_ the height!
     ASSERT(m_minSpaceShortage != RenderFlowThread::maxLogicalHeight()); // If this happens, we probably have a bug.
     if (m_minSpaceShortage == RenderFlowThread::maxLogicalHeight())
         return m_columnHeight; // So bail out rather than looping infinitely.
 
     return m_columnHeight + m_minSpaceShortage;
 }
 
 void RenderMultiColumnSet::addContentRun(LayoutUnit endOffsetFromFirstPage)
 {
-    if (!multiColumnFlowThread()->heightIsAuto())
+    if (!heightIsAuto())
         return;
     if (!m_contentRuns.isEmpty() && endOffsetFromFirstPage <= m_contentRuns.last().breakOffset())
         return;
     // Append another item as long as we haven't exceeded used column count. What ends up in the
     // overflow area shouldn't affect column balancing.
     if (m_contentRuns.size() < usedColumnCount())
         m_contentRuns.append(ContentRun(endOffsetFromFirstPage));
 }
 
 bool RenderMultiColumnSet::recalculateColumnHeight(BalancedHeightCalculation calculationMode)
 {
-    ASSERT(multiColumnFlowThread()->heightIsAuto());
+    LayoutUnit oldColumnHeight = m_columnHeight;
 
-    LayoutUnit oldColumnHeight = m_columnHeight;
-    if (calculationMode == GuessFromFlowThreadPortion) {
-        // Post-process the content runs and find out where the implicit breaks will occur.
-        distributeImplicitBreaks();
+    m_maxColumnHeight = calculateMaxColumnHeight();
+
+    if (heightIsAuto()) {
+        if (calculationMode == GuessFromFlowThreadPortion) {
+            // Post-process the content runs and find out where the implicit breaks will occur.
+            distributeImplicitBreaks();
+        }
+        LayoutUnit newColumnHeight = calculateColumnHeight(calculationMode);
+        setAndConstrainColumnHeight(newColumnHeight);
+        // After having calculated an initial column height, the multicol container typically needs at
+        // least one more layout pass with a new column height, but if a height was specified, we only
+        // need to do this if we think that we need less space than specified. Conversely, if we
+        // determined that the columns need to be as tall as the specified height of the container, we
+        // have already laid it out correctly, and there's no need for another pass.
+    } else {
+        // The position of the column set may have changed, in which case height available for
+        // columns may have changed as well.
+        setAndConstrainColumnHeight(m_columnHeight);
     }
-    LayoutUnit newColumnHeight = calculateColumnHeight(calculationMode);
-    setAndConstrainColumnHeight(newColumnHeight);
-
-    // After having calculated an initial column height, the multicol container typically needs at
-    // least one more layout pass with a new column height, but if a height was specified, we only
-    // need to do this if we think that we need less space than specified. Conversely, if we
-    // determined that the columns need to be as tall as the specified height of the container, we
-    // have already laid it out correctly, and there's no need for another pass.
 
     // We can get rid of the content runs now, if we haven't already done so. They are only needed
     // to calculate the initial balanced column height. In fact, we have to get rid of them before
     // the next layout pass, since each pass will rebuild this.
     m_contentRuns.clear();
 
     if (m_columnHeight == oldColumnHeight)
         return false; // No change. We're done.
 
     m_minSpaceShortage = RenderFlowThread::maxLogicalHeight();
@@ skipping 14 matching lines @@
 
 void RenderMultiColumnSet::resetColumnHeight()
 {
     // Nuke previously stored minimum column height. Contents may have changed for all we know.
     m_minimumColumnHeight = 0;
 
     m_maxColumnHeight = calculateMaxColumnHeight();
 
     LayoutUnit oldColumnHeight = pageLogicalHeight();
 
-    if (multiColumnFlowThread()->heightIsAuto())
+    if (heightIsAuto())
         m_columnHeight = 0;
     else
         setAndConstrainColumnHeight(heightAdjustedForSetOffset(multiColumnFlowThread()->columnHeightAvailable()));
 
     if (pageLogicalHeight() != oldColumnHeight)
         setChildNeedsLayout(MarkOnlyThis);
 
     // Content runs are only needed in the initial layout pass, in order to find an initial column
     // height, and should have been deleted afterwards. We're about to rebuild the content runs, so
     // the list needs to be empty.
@@ skipping 379 matching lines @@
     if (!hasOverflowClip())
         addVisualOverflow(lastRect);
 }
 
 const char* RenderMultiColumnSet::renderName() const
 {
     return "RenderMultiColumnSet";
 }
 
 }