[New Multicolumn] Preparatory work for nested multicol support.

Source/core/rendering/RenderMultiColumnSet.h

Index: Source/core/rendering/RenderMultiColumnSet.h
diff --git a/Source/core/rendering/RenderMultiColumnSet.h b/Source/core/rendering/RenderMultiColumnSet.h
index 263055e34947fc87a7c3125c1b29bcdbd928f925..68674d967177294d9ab0231906837afce8f640e7 100644
--- a/Source/core/rendering/RenderMultiColumnSet.h
+++ b/Source/core/rendering/RenderMultiColumnSet.h
@@ -27,6 +27,7 @@
 #ifndef RenderMultiColumnSet_h
 #define RenderMultiColumnSet_h
 
+#include "core/rendering/MultiColumnRow.h"
 #include "core/rendering/RenderMultiColumnFlowThread.h"
 #include "core/rendering/RenderRegion.h"
 #include "wtf/Vector.h"
@@ -50,16 +51,19 @@ namespace blink {
 //
 // Column spans result in the creation of new column sets, since a spanning renderer has to be
 // placed in between the column sets that come before and after the span.
+//
+// A multi column set has one or more column rows (MultiColumnRow objects). If we're inside another
+// fragmentation context, there will be one row established for each outer fragmentainer (page,
+// column, etc.) that this set lives in. If we're not inside another fragmentation context, on the
+// other hand, there will only be one row.
 class RenderMultiColumnSet : public RenderRegion {

[Julien - ping for review, 2015/01/29 17:37:47]

It would be nice to know how much is left of RenderMultiColumnSet after the
change. Maybe there won't be much meat left and we could think of a more simple
design?

[mstensho (USE GERRIT), 2015/02/02 17:57:24]

Yeah, those are interesting thoughts. I think RenderMultiColumnSet is still
useful though, for example when it comes to representing a contiguous run of
column content, but maybe we could reconsider that in the future?

Maybe we could get rid of both RenderMultiColumnSet and
RenderMultiColumnSpannerPlaceholder. But then we need to do manually what
RenderBlock layout does for us for free now (mainly positioning within the
multicol container, including margin collapsing).

 public:
-    enum BalancedHeightCalculation { GuessFromFlowThreadPortion, StretchBySpaceShortage };
-
     static RenderMultiColumnSet* createAnonymous(RenderFlowThread*, RenderStyle* parentStyle);
 
     virtual bool isOfType(RenderObjectType type) const override { return type == RenderObjectRenderMultiColumnSet || RenderRegion::isOfType(type); }
 
-    virtual LayoutUnit pageLogicalWidth() const override final { return flowThread()->logicalWidth(); }
-    virtual LayoutUnit pageLogicalHeight() const override final { return m_columnHeight; }
+    virtual LayoutUnit pageLogicalWidth() const final { return flowThread()->logicalWidth(); }
+    virtual LayoutUnit pageLogicalHeight() const final;
 
     RenderBlockFlow* multiColumnBlockFlow() const { return toRenderBlockFlow(parent()); }
     RenderMultiColumnFlowThread* multiColumnFlowThread() const
@@ -71,11 +75,9 @@ public:
     RenderMultiColumnSet* nextSiblingMultiColumnSet() const;
     RenderMultiColumnSet* previousSiblingMultiColumnSet() const;
 
-    void setLogicalTopInFlowThread(LayoutUnit);
-    LayoutUnit logicalTopInFlowThread() const { return isHorizontalWritingMode() ? flowThreadPortionRect().y() : flowThreadPortionRect().x(); }
-    LayoutUnit logicalHeightInFlowThread() const { return isHorizontalWritingMode() ? flowThreadPortionRect().height() : flowThreadPortionRect().width(); }
-    void setLogicalBottomInFlowThread(LayoutUnit);
-    LayoutUnit logicalBottomInFlowThread() const { return isHorizontalWritingMode() ? flowThreadPortionRect().maxY() : flowThreadPortionRect().maxX(); }
+    LayoutUnit logicalTopInFlowThread() const;
+    LayoutUnit logicalBottomInFlowThread() const;
+    LayoutUnit logicalHeightInFlowThread() const { return logicalBottomInFlowThread() - logicalTopInFlowThread(); }
 
     // The used CSS value of column-count, i.e. how many columns there are room for without overflowing.
     unsigned usedColumnCount() const { return multiColumnFlowThread()->columnCount(); }
@@ -86,10 +88,7 @@ public:
     // get from flow thread coordinates to visual coordinates.
     LayoutSize flowThreadTranslationAtOffset(LayoutUnit) const;
 
-    LayoutUnit heightAdjustedForSetOffset(LayoutUnit height) const;
-
-    void updateMinimumColumnHeight(LayoutUnit height) { m_minimumColumnHeight = std::max(height, m_minimumColumnHeight); }
-    LayoutUnit minimumColumnHeight() const { return m_minimumColumnHeight; }
+    void updateMinimumColumnHeight(LayoutUnit offsetInFlowThread, LayoutUnit height);
 
     // Add a content run, specified by its end position. A content run is appended at every
     // forced/explicit break and at the end of the column set. The content runs are used to
@@ -100,13 +99,13 @@ public:
     // (Re-)calculate the column height if it's auto. This is first and foremost needed by sets that
     // are to balance the column height, but even when it isn't to be balanced, this is necessary if
     // the multicol container's height is constrained.
-    virtual bool recalculateColumnHeight(BalancedHeightCalculation);
+    bool recalculateColumnHeight(BalancedColumnHeightCalculation);
 
     // Record space shortage (the amount of space that would have been enough to prevent some
     // element from being moved to the next column) at a column break. The smallest amount of space
     // shortage we find is the amount with which we will stretch the column height, if it turns out
     // after layout that the columns weren't tall enough.
-    void recordSpaceShortage(LayoutUnit spaceShortage);
+    void recordSpaceShortage(LayoutUnit offsetInFlowThread, LayoutUnit);
 
     // Reset previously calculated column height. Will mark for layout if needed.
     void resetColumnHeight();
@@ -115,6 +114,7 @@ public:
     // happens at the beginning of flow thread layout, and when advancing from a previous column set
     // or spanner to this one.
     void beginFlow(LayoutUnit offsetInFlowThread);
+
     // Layout of flow thread content that was to be rendered inside this column set has
     // finished. This happens at end of flow thread layout, and when advancing to the next column
     // set or spanner.
@@ -143,6 +143,29 @@ protected:
     RenderMultiColumnSet(RenderFlowThread*);
 
 private:
+    MultiColumnRow* firstColumnRow()
+    {
+        // FIXME: support multiple rows.
+        return &m_columnRow;
+    }
+    MultiColumnRow* lastColumnRow()

[Julien - ping for review, 2015/01/29 17:37:47]

Do we really want first / last? How about just some iterator instead of those
explicit columns?

[mstensho (USE GERRIT), 2015/02/02 17:57:24]

The first and the last groups are of special significance in certain parts of
the code (e.g. when finding the total flow thread portion for a column set).

Note that I've changed this code now, since groups are stored in a Vector now.
But we still have first / last.

+    {
+        // FIXME: support multiple rows.
+        return &m_columnRow;
+    }
+    MultiColumnRow* columnRowAtFlowThreadOffset(LayoutUnit);
+    const MultiColumnRow* firstColumnRow() const
+    {
+        // FIXME: support multiple rows.
+        return &m_columnRow;
+    }
+    const MultiColumnRow* lastColumnRow() const
+    {
+        // FIXME: support multiple rows.
+        return &m_columnRow;
+    }
+    const MultiColumnRow* columnRowAtFlowThreadOffset(LayoutUnit) const;
+
     virtual void insertedIntoTree() override final;
     virtual void willBeRemovedFromTree() override final;
 
@@ -156,82 +179,10 @@ private:
 
     virtual const char* renderName() const override;
 
-    LayoutUnit calculateMaxColumnHeight() const;
-    LayoutRect columnRectAt(unsigned index) const;
-
-
-    LayoutRect flowThreadPortionRectAt(unsigned index) const;
-    LayoutRect flowThreadPortionOverflowRect(const LayoutRect& flowThreadPortion, unsigned index, unsigned colCount, LayoutUnit colGap) const;
-
-    enum ColumnIndexCalculationMode {
-        ClampToExistingColumns, // Stay within the range of already existing columns.
-        AssumeNewColumns // Allow column indices outside the range of already existing columns.
-    };
-    unsigned columnIndexAtOffset(LayoutUnit, ColumnIndexCalculationMode = ClampToExistingColumns) const;
-
-    void setAndConstrainColumnHeight(LayoutUnit);
-
-    // Return the index of the content run with the currently tallest columns, taking all implicit
-    // breaks assumed so far into account.
-    unsigned findRunWithTallestColumns() const;
-
-    // Given the current list of content runs, make assumptions about where we need to insert
-    // implicit breaks (if there's room for any at all; depending on the number of explicit breaks),
-    // and store the results. This is needed in order to balance the columns.
-    void distributeImplicitBreaks();
-
-    LayoutUnit calculateColumnHeight(BalancedHeightCalculation) const;
-
-    LayoutUnit m_columnHeight;
-
-    // The following variables are used when balancing the column set.
-    LayoutUnit m_maxColumnHeight; // Maximum column height allowed.
-    LayoutUnit m_minSpaceShortage; // The smallest amout of space shortage that caused a column break.
-    LayoutUnit m_minimumColumnHeight;
-
-    // A run of content without explicit (forced) breaks; i.e. a flow thread portion between two
-    // explicit breaks, between flow thread start and an explicit break, between an explicit break
-    // and flow thread end, or, in cases when there are no explicit breaks at all: between flow
-    // thread portion start and flow thread portion end. We need to know where the explicit breaks
-    // are, in order to figure out where the implicit breaks will end up, so that we get the columns
-    // properly balanced. A content run starts out as representing one single column, and will
-    // represent one additional column for each implicit break "inserted" there.
-    class ContentRun {
-    public:
-        ContentRun(LayoutUnit breakOffset)
-            : m_breakOffset(breakOffset)
-            , m_assumedImplicitBreaks(0) { }
-
-        unsigned assumedImplicitBreaks() const { return m_assumedImplicitBreaks; }
-        void assumeAnotherImplicitBreak() { m_assumedImplicitBreaks++; }
-        LayoutUnit breakOffset() const { return m_breakOffset; }
-
-        // Return the column height that this content run would require, considering the implicit
-        // breaks assumed so far.
-        LayoutUnit columnLogicalHeight(LayoutUnit startOffset) const { return ceilf((m_breakOffset - startOffset).toFloat() / float(m_assumedImplicitBreaks + 1)); }
-
-    private:
-        LayoutUnit m_breakOffset; // Flow thread offset where this run ends.
-        unsigned m_assumedImplicitBreaks; // Number of implicit breaks in this run assumed so far.
-    };
-    Vector<ContentRun, 1> m_contentRuns;
-};
+    virtual LayoutRect flowThreadPortionRect() const override;
 
-inline void RenderMultiColumnSet::beginFlow(LayoutUnit offsetInFlowThread)
-{
-    // At this point layout is exactly at the beginning of this set. Store block offset from flow
-    // thread start.
-    setLogicalTopInFlowThread(offsetInFlowThread);
-}
-
-inline void RenderMultiColumnSet::endFlow(LayoutUnit offsetInFlowThread)
-{
-    // At this point layout is exactly at the end of this set. Store block offset from flow thread
-    // start. This set is now considered "flowed", although we may have to revisit it later (with
-    // beginFlow()), e.g. if a subtree in the flow thread has to be laid out over again because the
-    // initial margin collapsing estimates were wrong.
-    setLogicalBottomInFlowThread(offsetInFlowThread);
-}
+    MultiColumnRow m_columnRow; // FIXME: Need to support multiple rows.
+};
 
 DEFINE_RENDER_OBJECT_TYPE_CASTS(RenderMultiColumnSet, isRenderMultiColumnSet());