[New Multicolumn] Use the term "content run" in favor of "forced break".

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 83 matching lines @@
     m_computedColumnHeight = newHeight;
     if (m_computedColumnHeight > m_maxColumnHeight)
         m_computedColumnHeight = m_maxColumnHeight;
     // FIXME: the height may also be affected by the enclosing pagination context, if any.
 }
 
 unsigned RenderMultiColumnSet::findRunWithTallestColumns() const
 {
     unsigned indexWithLargestHeight = 0;
     LayoutUnit largestHeight;
-    LayoutUnit previousOffset;
+    LayoutUnit previousOffset = logicalTopInFlowThread();
     size_t runCount = m_contentRuns.size();
     ASSERT(runCount);
     for (size_t i = 0; i < runCount; i++) {
         const ContentRun& run = m_contentRuns[i];
         LayoutUnit height = run.columnLogicalHeight(previousOffset);
         if (largestHeight < height) {
             largestHeight = height;
             indexWithLargestHeight = i;
         }
         previousOffset = run.breakOffset();
     }
     return indexWithLargestHeight;
 }
 
 void RenderMultiColumnSet::distributeImplicitBreaks()
 {
 #ifndef NDEBUG
     // There should be no implicit breaks assumed at this point.
-    for (unsigned i = 0; i < forcedBreaksCount(); i++)
+    for (unsigned i = 0; i < m_contentRuns.size(); i++)
         ASSERT(!m_contentRuns[i].assumedImplicitBreaks());
 #endif // NDEBUG
 
     // Insert a final content run to encompass all content. This will include overflow if this is
     // the last set.
-    addForcedBreak(logicalBottomInFlowThread());
-    unsigned breakCount = forcedBreaksCount();
+    addContentRun(logicalBottomInFlowThread());
+    unsigned columnCount = m_contentRuns.size();
 
     // If there is room for more breaks (to reach the used value of column-count), imagine that we
     // insert implicit breaks at suitable locations. At any given time, the content run with the
     // currently tallest columns will get another implicit break "inserted", which will increase its
     // column count by one and shrink its columns' height. Repeat until we have the desired total
     // number of breaks. The largest column height among the runs will then be the initial column
     // height for the balancer to use.
-    while (breakCount < m_computedColumnCount) {
+    while (columnCount < m_computedColumnCount) {
         unsigned index = findRunWithTallestColumns();
         m_contentRuns[index].assumeAnotherImplicitBreak();
-        breakCount++;
+        columnCount++;
     }
 }
 
 LayoutUnit RenderMultiColumnSet::calculateColumnHeight(bool initial) const
 {
     if (initial) {
-        // Start with the lowest imaginable column height.
+        // Start with the lowest imaginable column height. We use the tallest content run (after
+        // having "inserted" implicit breaks), and find its start offset (by looking at the previous
+        // run's end offset, or, if there's no previous run, the set's start offset in the flow
+        // thread).
         unsigned index = findRunWithTallestColumns();
-        LayoutUnit startOffset = index > 0 ? m_contentRuns[index - 1].breakOffset() : LayoutUnit();
+        LayoutUnit startOffset = index > 0 ? m_contentRuns[index - 1].breakOffset() : logicalTopInFlowThread();
         return std::max<LayoutUnit>(m_contentRuns[index].columnLogicalHeight(startOffset), m_minimumColumnHeight);
     }
 
     if (columnCount() <= computedColumnCount()) {
         // With the current column height, the content fits without creating overflowing columns. We're done.
         return m_computedColumnHeight;
     }
 
-    if (forcedBreaksCount() >= computedColumnCount()) {
+    if (m_contentRuns.size() >= computedColumnCount()) {
         // Too many forced breaks to allow any implicit breaks. Initial balancing should already
         // have set a good height. There's nothing more we should do.
         return m_computedColumnHeight;
     }
 
     // If the initial guessed column height wasn't enough, stretch it now. Stretch by the lowest
     // amount of space shortage found during layout.
 
     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_computedColumnHeight; // So bail out rather than looping infinitely.
 
     return m_computedColumnHeight + m_minSpaceShortage;
 }
 
-void RenderMultiColumnSet::clearForcedBreaks()
-{
-    m_contentRuns.clear();
-}
-
-void RenderMultiColumnSet::addForcedBreak(LayoutUnit offsetFromFirstPage)
+void RenderMultiColumnSet::addContentRun(LayoutUnit endOffsetFromFirstPage)
 {
     if (!multiColumnFlowThread()->requiresBalancing())
         return;
-    if (!m_contentRuns.isEmpty() && offsetFromFirstPage <= m_contentRuns.last().breakOffset())
+    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() < m_computedColumnCount)
-        m_contentRuns.append(ContentRun(offsetFromFirstPage));
+        m_contentRuns.append(ContentRun(endOffsetFromFirstPage));
 }
 
 bool RenderMultiColumnSet::recalculateColumnHeight(bool initial)
 {
     ASSERT(multiColumnFlowThread()->requiresBalancing());
 
     LayoutUnit oldColumnHeight = m_computedColumnHeight;
-    if (initial)
+    if (initial) {
+        // Post-process the content runs and find out where the implicit breaks will occur.
         distributeImplicitBreaks();
+    }
     LayoutUnit newColumnHeight = calculateColumnHeight(initial);
     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.
 
     if (m_computedColumnHeight == oldColumnHeight)
         return false; // No change. We're done.
 
     m_minSpaceShortage = RenderFlowThread::maxLogicalHeight();
-    clearForcedBreaks();
+    m_contentRuns.clear();
     return true; // Need another pass.
 }
 
 void RenderMultiColumnSet::recordSpaceShortage(LayoutUnit spaceShortage)
 {
     if (spaceShortage >= m_minSpaceShortage)
         return;
 
     // The space shortage is what we use as our stretch amount. We need a positive number here in
     // order to get anywhere.
@@ skipping 48 matching lines @@
             LayoutUnit logicalMaxHeight = multicolBlock->computeContentLogicalHeight(multicolStyle->logicalMaxHeight(), -1);
             if (logicalMaxHeight != -1 && m_maxColumnHeight > logicalMaxHeight)
                 m_maxColumnHeight = logicalMaxHeight;
         }
         m_maxColumnHeight = heightAdjustedForSetOffset(m_maxColumnHeight);
         m_computedColumnHeight = 0; // Restart balancing.
     } else {
         setAndConstrainColumnHeight(heightAdjustedForSetOffset(multiColumnFlowThread()->columnHeightAvailable()));
     }
 
-    clearForcedBreaks();
+    m_contentRuns.clear();
 
     // Nuke previously stored minimum column height. Contents may have changed for all we know.
     m_minimumColumnHeight = 0;
 }
 
 void RenderMultiColumnSet::expandToEncompassFlowThreadContentsIfNeeded()
 {
     ASSERT(multiColumnFlowThread()->lastMultiColumnSet() == this);
     LayoutRect rect(flowThreadPortionRect());
 
@@ skipping 327 matching lines @@
         fragments.append(fragment);
     }
 }
 
 const char* RenderMultiColumnSet::renderName() const
 {
     return "RenderMultiColumnSet";
 }
 
 }