Deduct pagination struts when calculating initial column height.

third_party/WebKit/Source/core/layout/ColumnBalancer.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "core/layout/ColumnBalancer.h"
 
 #include "core/layout/LayoutMultiColumnSet.h"
 
@@ skipping 60 matching lines @@
             traverseSubtree(childBox);
         examineBoxBeforeLeaving(childBox);
 
         m_flowThreadOffset -= offsetForThisChild;
     }
 }
 
 InitialColumnHeightFinder::InitialColumnHeightFinder(const MultiColumnFragmentainerGroup& group)
     : ColumnBalancer(group)
 {
+    m_struts.resize(group.columnSet().usedColumnCount());
+    for (auto& strut : m_struts)
+        strut = LayoutUnit::max();
     traverse();
     // We have now found each explicit / forced break, and their location. Now we need to figure out
     // how many additional implicit / soft breaks we need and guess where they will occur, in order
     // to provide an initial column height.
     distributeImplicitBreaks();
 }
 
 LayoutUnit InitialColumnHeightFinder::initialMinimalBalancedHeight() const
 {
     unsigned index = contentRunIndexWithTallestColumns();
     LayoutUnit startOffset = index > 0 ? m_contentRuns[index - 1].breakOffset() : group().logicalTopInFlowThread();
     return m_contentRuns[index].columnLogicalHeight(startOffset);
 }
 
 void InitialColumnHeightFinder::examineBoxAfterEntering(const LayoutBox& box)
 {
     ASSERT(isFirstAfterBreak(flowThreadOffset()) || !box.paginationStrut());
-    if (box.hasForcedBreakBefore())
+    if (box.hasForcedBreakBefore()) {
         addContentRun(flowThreadOffset());
+    } else if (isFirstAfterBreak(flowThreadOffset())) {
+        // This box is first after a soft break.
+        recordStrutBeforeOffset(flowThreadOffset(), box.paginationStrut());
+    }
+
     if (box.hasForcedBreakAfter())
         addContentRun(flowThreadOffset() + box.logicalHeight());
 }
 
 void InitialColumnHeightFinder::examineBoxBeforeLeaving(const LayoutBox& box)
 {
 }
 
 void InitialColumnHeightFinder::examineLine(const RootInlineBox& line)
 {
+    LayoutUnit lineTop = line.lineTopWithLeading();
+    LayoutUnit lineTopInFlowThread = flowThreadOffset() + lineTop;
+    ASSERT(isFirstAfterBreak(lineTopInFlowThread) || !line.paginationStrut());
+    if (isFirstAfterBreak(lineTopInFlowThread))
+        recordStrutBeforeOffset(lineTopInFlowThread, line.paginationStrut());
+}
+
+void InitialColumnHeightFinder::recordStrutBeforeOffset(LayoutUnit offsetInFlowThread, LayoutUnit strut)
+{
+    const LayoutMultiColumnSet& columnSet = group().columnSet();
+    ASSERT(columnSet.usedColumnCount() >= 1);
+    unsigned columnCount = columnSet.usedColumnCount();
+    ASSERT(m_struts.size() == columnCount);
+    unsigned index = group().columnIndexAtOffset(offsetInFlowThread - strut, MultiColumnFragmentainerGroup::AssumeNewColumns);
+    if (index >= columnCount)
+        return;
+    m_struts[index] = std::min(m_struts[index], strut);
+}
+
+LayoutUnit InitialColumnHeightFinder::spaceUsedByStrutsAt(LayoutUnit offsetInFlowThread) const
+{
+    unsigned stopBeforeColumn = group().columnIndexAtOffset(offsetInFlowThread, MultiColumnFragmentainerGroup::AssumeNewColumns) + 1;
+    stopBeforeColumn = std::min(stopBeforeColumn, group().columnSet().usedColumnCount());
+    ASSERT(stopBeforeColumn <= m_struts.size());
+    LayoutUnit totalStrut;

[leviw_travelin_and_unemployed, 2015/10/30 20:10:50]

totalStrutSpace or something like that?

[mstensho (USE GERRIT), 2015/11/02 09:12:28]

Done.

+    for (unsigned i = 0; i < stopBeforeColumn; i++) {
+        if (m_struts[i] != LayoutUnit::max())
+            totalStrut += m_struts[i];
+    }
+    return totalStrut;
 }
 
 void InitialColumnHeightFinder::addContentRun(LayoutUnit endOffsetInFlowThread)
 {
+    endOffsetInFlowThread -= spaceUsedByStrutsAt(endOffsetInFlowThread);
     if (!m_contentRuns.isEmpty() && endOffsetInFlowThread <= 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() < group().columnSet().usedColumnCount())
         m_contentRuns.append(ContentRun(endOffsetInFlowThread));
 }
 
 unsigned InitialColumnHeightFinder::contentRunIndexWithTallestColumns() const
 {
@@ skipping 111 matching lines @@
         recordSpaceShortage(logicalOffsetFromCurrentColumn + lineHeight - m_pendingStrut);
         m_pendingStrut = LayoutUnit::min();
         return;
     }
     ASSERT(isFirstAfterBreak(lineTopInFlowThread) || !line.paginationStrut());
     if (isFirstAfterBreak(lineTopInFlowThread))
         recordSpaceShortage(lineHeight - line.paginationStrut());
 }
 
 } // namespace blink