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

Source/core/rendering/RenderMultiColumnSet.h

 /*
  * 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 41 matching lines @@
 // placed in between the column sets that come before and after the span.
 class RenderMultiColumnSet : public RenderRegion {
 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 pageLogicalHeight() const override { return m_columnHeight; }
 
     RenderBlockFlow* multiColumnBlockFlow() const { return toRenderBlockFlow(parent()); }
     RenderMultiColumnFlowThread* multiColumnFlowThread() const
     {
         ASSERT_WITH_SECURITY_IMPLICATION(!flowThread() || flowThread()->isRenderMultiColumnFlowThread());
         return static_cast<RenderMultiColumnFlowThread*>(flowThread());
     }
 
     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 logicalHeightInFlowThread() const { return isHorizontalWritingMode() ? flowThreadPortionRect().height() : flowThreadPortionRect().width(); }
-
     // The used CSS value of column-count, i.e. how many columns there are room for without overflowing.
     unsigned usedColumnCount() const { return multiColumnFlowThread()->columnCount(); }
 
+    bool heightIsAuto() const;
+
+    bool requiresBalancing() const { return !isRenderMultiColumnSpannerSet() && heightIsAuto(); }
+
     // Find the column that contains the given block offset, and return the translation needed to
     // 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; }
 
     // 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
     // determine where implicit/soft breaks will occur, in order to calculate an initial column
     // height.
     void addContentRun(LayoutUnit endOffsetFromFirstPage);
 
-    // (Re-)calculate the column height if it's auto.
+    // (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);
 
     // 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);
 
     // Reset previously calculated column height. Will mark for layout if needed.
     void resetColumnHeight();
 
+    // Layout of flow thread content that's to be rendered inside this column set begins. This
+    // 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.
+    void endFlow(LayoutUnit offsetInFlowThread);
+
     // Expand this set's flow thread portion rectangle to contain all trailing flow thread
     // overflow. Only to be called on the last set.
     void expandToEncompassFlowThreadContentsIfNeeded();
 
     void attachRegion();
     void detachRegion();
 
     void paintInvalidationForFlowThreadContent(const LayoutRect& paintInvalidationRect) const;
 
     // The top of the nearest page inside the region. For RenderRegions, this is just the logical top of the
@@ skipping 77 matching lines @@
         // 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;
 };
 
+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);
+}
+
 DEFINE_RENDER_OBJECT_TYPE_CASTS(RenderMultiColumnSet, isRenderMultiColumnSet());
 
 } // namespace blink
 
 #endif // RenderMultiColumnSet_h