Initial support for nested multicol layout.

Source/core/layout/LayoutMultiColumnSet.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 32 matching lines @@
 
 LayoutMultiColumnSet* LayoutMultiColumnSet::createAnonymous(LayoutFlowThread& flowThread, const ComputedStyle& parentStyle)
 {
     Document& document = flowThread.document();
     LayoutMultiColumnSet* layoutObject = new LayoutMultiColumnSet(&flowThread);
     layoutObject->setDocumentForAnonymous(&document);
     layoutObject->setStyle(ComputedStyle::createAnonymousStyleWithDisplay(parentStyle, BLOCK));
     return layoutObject;
 }
 
-MultiColumnFragmentainerGroup& LayoutMultiColumnSet::fragmentainerGroupAtFlowThreadOffset(LayoutUnit)
+unsigned LayoutMultiColumnSet::fragmentainerGroupIndexAtFlowThreadOffset(LayoutUnit flowThreadOffset) const
 {
-    // FIXME: implement this, once we have support for multiple rows.
-    return m_fragmentainerGroups.first();
-}
-
-const MultiColumnFragmentainerGroup& LayoutMultiColumnSet::fragmentainerGroupAtFlowThreadOffset(LayoutUnit) const
-{
-    // FIXME: implement this, once we have support for multiple rows.
-    return m_fragmentainerGroups.first();
+    ASSERT(m_fragmentainerGroups.size() > 0);
+    if (flowThreadOffset <= 0)
+        return 0;
+    // TODO(mstensho): Introduce an interval tree or similar to speed up this.
+    for (unsigned index = 0; index < m_fragmentainerGroups.size(); index++) {
+        const auto& row = m_fragmentainerGroups[index];
+        if (row.logicalTopInFlowThread() <= flowThreadOffset && row.logicalBottomInFlowThread() > flowThreadOffset)
+            return index;
+    }
+    return m_fragmentainerGroups.size() - 1;
 }
 
 const MultiColumnFragmentainerGroup& LayoutMultiColumnSet::fragmentainerGroupAtVisualPoint(const LayoutPoint&) const
 {
     // FIXME: implement this, once we have support for multiple rows.
     return m_fragmentainerGroups.first();
 }
 
 LayoutUnit LayoutMultiColumnSet::pageLogicalHeightForOffset(LayoutUnit offsetInFlowThread) const
 {
@@ skipping 33 matching lines @@
 
 LayoutMultiColumnSet* LayoutMultiColumnSet::previousSiblingMultiColumnSet() const
 {
     for (LayoutObject* sibling = previousSibling(); sibling; sibling = sibling->previousSibling()) {
         if (sibling->isLayoutMultiColumnSet())
             return toLayoutMultiColumnSet(sibling);
     }
     return nullptr;
 }
 
+MultiColumnFragmentainerGroup& LayoutMultiColumnSet::appendNewFragmentainerGroup()
+{
+    MultiColumnFragmentainerGroup newGroup(*this);
+    { // extra scope here for previousGroup; it's potentially invalid once we modify the m_fragmentainerGroups Vector.

[leviw_travelin_and_unemployed, 2015/08/15 00:04:43]

Nit: capitalize extra.

[mstensho (USE GERRIT), 2015/08/17 07:43:09]

done

+        MultiColumnFragmentainerGroup& previousGroup = m_fragmentainerGroups.last();
+
+        // This is the flow thread block offset where |previousGroup| ends and |newGroup| takes over.
+        LayoutUnit blockOffsetInFlowThread = previousGroup.logicalTopInFlowThread() + previousGroup.logicalHeight() * usedColumnCount();
+        previousGroup.setLogicalBottomInFlowThread(blockOffsetInFlowThread);
+        newGroup.setLogicalTopInFlowThread(blockOffsetInFlowThread);
+
+        newGroup.setLogicalTop(previousGroup.logicalTop() + previousGroup.logicalHeight());
+        newGroup.resetColumnHeight();
+    }
+    m_fragmentainerGroups.append(newGroup);
+    return m_fragmentainerGroups.last();
+}
+
 LayoutUnit LayoutMultiColumnSet::logicalTopInFlowThread() const
 {
     return firstFragmentainerGroup().logicalTopInFlowThread();
 }
 
 LayoutUnit LayoutMultiColumnSet::logicalBottomInFlowThread() const
 {
     return lastFragmentainerGroup().logicalBottomInFlowThread();
 }
 
@@ skipping 83 matching lines @@
 bool LayoutMultiColumnSet::recalculateColumnHeight(BalancedColumnHeightCalculation calculationMode)
 {
     bool changed = false;
     for (auto& group : m_fragmentainerGroups)
         changed = group.recalculateColumnHeight(calculationMode) || changed;
     return changed;
 }
 
 void LayoutMultiColumnSet::recordSpaceShortage(LayoutUnit offsetInFlowThread, LayoutUnit spaceShortage)
 {
-    fragmentainerGroupAtFlowThreadOffset(offsetInFlowThread).recordSpaceShortage(spaceShortage);
+    MultiColumnFragmentainerGroup& row = fragmentainerGroupAtFlowThreadOffset(offsetInFlowThread);
+    row.recordSpaceShortage(spaceShortage);
+
+    // Since we're at a potential break here, take the opportunity to check if we need another
+    // fragmentainer group. If we've run out of columns in the last fragmentainer group (column
+    // row), we need to insert another fragmentainer group to hold more columns.
+    if (!row.isLastGroup())
+        return;
+    LayoutMultiColumnFlowThread* flowThread = multiColumnFlowThread();
+    if (!flowThread->multiColumnBlockFlow()->isInsideFlowThread())
+        return; // Early bail. We're not nested, so waste no more time on this.
+    if (!flowThread->isInInitialLayoutPass())
+        return;
+    // Move the offset to where the next column starts, if we're not there already.
+    offsetInFlowThread += flowThread->pageRemainingLogicalHeightForOffset(offsetInFlowThread, AssociateWithFormerPage);
+
+    flowThread->appendNewFragmentainerGroupIfNeeded(offsetInFlowThread);
 }
 
 void LayoutMultiColumnSet::resetColumnHeight()
 {
     m_fragmentainerGroups.deleteExtraGroups();
     m_fragmentainerGroups.first().resetColumnHeight();
 }
 
 void LayoutMultiColumnSet::beginFlow(LayoutUnit offsetInFlowThread)
 {
@@ skipping 115 matching lines @@
 
 LayoutRect LayoutMultiColumnSet::flowThreadPortionRect() const
 {
     LayoutRect portionRect(LayoutUnit(), logicalTopInFlowThread(), pageLogicalWidth(), logicalHeightInFlowThread());
     if (!isHorizontalWritingMode())
         return portionRect.transposedRect();
     return portionRect;
 }
 
 }