[New Multicolumn] Add support for 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 32 matching lines @@
 // Being a "region", a column set has no children on its own, but is merely used to slice a portion
 // of the tall "single-column" flow thread into actual columns visually, to convert from flow thread
 // coordinates to visual ones. It is in charge of both positioning columns correctly relatively to
 // the parent multicol container, and to calculate the correct translation for each column's
 // contents, and to paint any rules between them. RenderMultiColumnSet objects are used for
 // painting, hit testing, and any other type of operation that requires mapping from flow thread
 // coordinates to visual coordinates.
 //
 // 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.
-class RenderMultiColumnSet FINAL : public RenderRegion {
+class RenderMultiColumnSet : public RenderRegion {
 public:
     enum BalancedHeightCalculation { GuessFromFlowThreadPortion, StretchBySpaceShortage };
 
     static RenderMultiColumnSet* createAnonymous(RenderFlowThread*, RenderStyle* parentStyle);
 
     virtual bool isRenderMultiColumnSet() const OVERRIDE { return true; }
 
     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.
-    bool recalculateColumnHeight(BalancedHeightCalculation);
+    // (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();
 
+    // Prepare this set for flow thread layout.
+    void resetFlow();
+    // 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();
 
     // This method represents the logical height of the entire flow thread portion used by the region or set.
     // For RenderRegions it matches logicalPaginationHeight(), but for sets it is the height of all the pages
     // or columns added together.
     LayoutUnit logicalHeightOfAllFlowThreadContent() const { return logicalHeightInFlowThread(); }
 
     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
     // flow thread portion we contain. For sets, we have to figure out the top of the nearest column or
     // page.
     LayoutUnit pageLogicalTopForOffset(LayoutUnit offset) const;
 
     void collectLayerFragments(LayerFragments&, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect);
 
-private:
+protected:
     RenderMultiColumnSet(RenderFlowThread*);
 
+private:
     virtual void insertedIntoTree() OVERRIDE FINAL;
     virtual void willBeRemovedFromTree() OVERRIDE FINAL;
 
     virtual void computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues&) const OVERRIDE;
 
     virtual void paintObject(PaintInfo&, const LayoutPoint& paintOffset) OVERRIDE;
 
     virtual void addOverflowFromChildren() OVERRIDE;
 
     virtual const char* renderName() const OVERRIDE;
@@ skipping 57 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::resetFlow()
+{
+    // Start with "infinite" flow thread portion height until height is known.
+    setLogicalBottomInFlowThread(RenderFlowThread::maxLogicalHeight());
+}
+
+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