All ancestor multicols must have enough rows before laying out some inner multicol.

third_party/WebKit/Source/core/layout/LayoutMultiColumnFlowThread.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 366 matching lines @@
     return adapter.result();
 }
 
 void LayoutMultiColumnFlowThread::layoutColumns(SubtreeLayoutScope& layoutScope)
 {
     // Since we ended up here, it means that the multicol container (our parent) needed
     // layout. Since contents of the multicol container are diverted to the flow thread, the flow
     // thread needs layout as well.
     layoutScope.setChildNeedsLayout(this);
 
-    m_blockOffsetInEnclosingFragmentationContext = enclosingFragmentationContext() ? multiColumnBlockFlow()->offsetFromLogicalTopOfFirstPage() : LayoutUnit();
+    if (FragmentationContext* enclosingFragmentationContext = this->enclosingFragmentationContext()) {
+        m_blockOffsetInEnclosingFragmentationContext = multiColumnBlockFlow()->offsetFromLogicalTopOfFirstPage();
+
+        if (LayoutMultiColumnFlowThread* enclosingFlowThread = enclosingFragmentationContext->associatedFlowThread()) {
+            if (LayoutMultiColumnSet* firstSet = firstMultiColumnSet()) {
+                // Before we can start to lay out the contents of this multicol container, we need
+                // to make sure that all ancestor multicol containers have established a row to hold
+                // the first column contents of this container (this multicol container may start at
+                // the beginning of a new outer row). Without sufficient rows in all ancestor
+                // multicol containers, we may use the wrong column height.
+                LayoutUnit offset = m_blockOffsetInEnclosingFragmentationContext + firstSet->logicalTopFromMulticolContentEdge();
+                enclosingFlowThread->appendNewFragmentainerGroupIfNeeded(offset, AssociateWithLatterPage);
+            }
+        }
+    }
 
     for (LayoutBox* columnBox = firstMultiColumnBox(); columnBox; columnBox = columnBox->nextSiblingMultiColumnBox()) {
         if (!columnBox->isLayoutMultiColumnSet()) {
             ASSERT(columnBox->isLayoutMultiColumnSpannerPlaceholder()); // no other type is expected.
             continue;
         }
         LayoutMultiColumnSet* columnSet = toLayoutMultiColumnSet(columnBox);
         layoutScope.setChildNeedsLayout(columnSet);
         if (!m_columnHeightsChanged) {
             // This is the initial layout pass. We need to reset the column height, because contents
@@ skipping 50 matching lines @@
     return nullptr;
 }
 
 FragmentationContext* LayoutMultiColumnFlowThread::enclosingFragmentationContext() const
 {
     if (LayoutMultiColumnFlowThread* enclosingFlowThread = this->enclosingFlowThread())
         return enclosingFlowThread;
     return view()->fragmentationContext();
 }
 
-void LayoutMultiColumnFlowThread::appendNewFragmentainerGroupIfNeeded(LayoutUnit bottomOffsetInFlowThread)
+void LayoutMultiColumnFlowThread::appendNewFragmentainerGroupIfNeeded(LayoutUnit offsetInFlowThread, PageBoundaryRule pageBoundaryRule)
 {
     if (!isPageLogicalHeightKnown()) {
         // If we have no clue about the height of the multicol container, bail. This situation
         // occurs initially when an auto-height multicol container is nested inside another
         // auto-height multicol container. We need at least an estimated height of the outer
         // multicol container before we can check what an inner fragmentainer group has room for.
         // Its height is indefinite for now.
         return;
     }
-    // TODO(mstensho): bottomOffsetInFlowThread is an endpoint-exclusive offset, i.e. the offset
-    // just after the bottom of some object. So, ideally, columnSetAtBlockOffset() should be
-    // informed about this (i.e. take a PageBoundaryRule argument). This is not the only place with
-    // this issue; see also pageRemainingLogicalHeightForOffset().
-    LayoutMultiColumnSet* columnSet = columnSetAtBlockOffset(bottomOffsetInFlowThread);
+    // TODO(mstensho): If pageBoundaryRule is AssociateWithFormerPage, offsetInFlowThread is an
+    // endpoint-exclusive offset, i.e. the offset just after the bottom of some object. So, ideally,
+    // columnSetAtBlockOffset() should be informed about this (i.e. take a PageBoundaryRule
+    // argument). This is not the only place with this issue; see also
+    // pageRemainingLogicalHeightForOffset().
+    LayoutMultiColumnSet* columnSet = columnSetAtBlockOffset(offsetInFlowThread);
     if (columnSet->isInitialHeightCalculated()) {
         // We only insert additional fragmentainer groups in the initial layout pass. We only want
         // to balance columns in the last fragmentainer group (if we need to balance at all), so we
         // want that last fragmentainer group to be the same one in all layout passes that follow.
         return;
     }
 
-    if (!columnSet->hasFragmentainerGroupForColumnAt(bottomOffsetInFlowThread)) {
+    if (!columnSet->hasFragmentainerGroupForColumnAt(offsetInFlowThread, pageBoundaryRule)) {
         FragmentationContext* enclosingFragmentationContext = this->enclosingFragmentationContext();
         if (!enclosingFragmentationContext)
             return; // Not nested. We'll never need more rows than the one we already have then.
         ASSERT(!isLayoutPagedFlowThread());
         // We have run out of columns here, so we add another row to hold more columns. When we add
         // a new row, it implicitly means that we're inserting another column in our enclosing
         // multicol container. That in turn may mean that we've run out of columns there too.
         const MultiColumnFragmentainerGroup& newRow = columnSet->appendNewFragmentainerGroup();
         if (LayoutMultiColumnFlowThread* enclosingFlowThread = enclosingFragmentationContext->associatedFlowThread())
-            enclosingFlowThread->appendNewFragmentainerGroupIfNeeded(newRow.blockOffsetInEnclosingFragmentationContext() + newRow.logicalHeight());
+            enclosingFlowThread->appendNewFragmentainerGroupIfNeeded(newRow.blockOffsetInEnclosingFragmentationContext(), AssociateWithLatterPage);
     }
 }
 
 bool LayoutMultiColumnFlowThread::isFragmentainerLogicalHeightKnown()
 {
     return isPageLogicalHeightKnown();
 }
 
 LayoutUnit LayoutMultiColumnFlowThread::fragmentainerLogicalHeightAt(LayoutUnit blockOffset)
 {
@@ skipping 448 matching lines @@
     // First figure out if there's any chance that we're nested at all. If we can be sure that
     // we're not, bail early. This code is run very often, and since locating a containing flow
     // thread has some cost (depending on tree depth), avoid calling
     // enclosingFragmentationContext() right away. This test may give some false positives (hence
     // the "mayBe"), if we're in an out-of-flow subtree and have an outer multicol container that
     // doesn't affect us, but that's okay. We'll discover that further down the road when trying to
     // locate our enclosing flow thread for real.
     bool mayBeNested = multiColumnBlockFlow()->isInsideFlowThread() || view()->fragmentationContext();
     if (!mayBeNested)
         return;
-    appendNewFragmentainerGroupIfNeeded(logicalBottomInFlowThreadAfterPagination);
+    appendNewFragmentainerGroupIfNeeded(logicalBottomInFlowThreadAfterPagination, AssociateWithFormerPage);
 }
 
 bool LayoutMultiColumnFlowThread::canSkipLayout(const LayoutBox& root) const
 {
     // Objects containing spanners is all we need to worry about, so if there are no spanners at all
     // in this multicol container, we can just return the good news right away.
     if (!hasAnyColumnSpanners(*this))
         return true;
 
     LayoutObject* next;
     for (const LayoutObject* object = &root; object; object = next) {
         if (object->isColumnSpanAll()) {
             // A spanner potentially ends one fragmentainer group and begins a new one, and thus
             // determines the flow thread portion bottom and top of adjacent fragmentainer
             // groups. It's just too hard to guess these values without laying out.
             return false;
         }
         if (canContainSpannerInParentFragmentationContext(*object))
             next = object->nextInPreOrder(&root);
         else
             next = object->nextInPreOrderAfterChildren(&root);
     }
     return true;
 }
 
 } // namespace blink