It's not just the last column set that may need additional fragmentainer groups.

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 421 matching lines @@
     return true;
 }
 
 LayoutMultiColumnFlowThread* LayoutMultiColumnFlowThread::enclosingFlowThread() const
 {
     if (multiColumnBlockFlow()->isInsideFlowThread())
         return toLayoutMultiColumnFlowThread(locateFlowThreadContainingBlockOf(*multiColumnBlockFlow()));
     return nullptr;
 }
 
-bool LayoutMultiColumnFlowThread::hasFragmentainerGroupForColumnAt(LayoutUnit offsetInFlowThread) const
+void LayoutMultiColumnFlowThread::appendNewFragmentainerGroupIfNeeded(LayoutUnit offsetInFlowThread)
 {
-    // If there's no enclosing flow thread, there'll always be only one fragmentainer group, and it
-    // can hold as many columns as we like. We shouldn't even be here in that case.
-    ASSERT(enclosingFlowThread());
-
     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 height is indefinite for now.

[leviw_travelin_and_unemployed, 2015/12/01 22:11:20]

Let's fix this comment while we're here. I suspect only one of its heights is
unknown at this point ;)

[mstensho (USE GERRIT), 2015/12/01 23:00:29]

Done.

-        return true;
+        return;
+    }
+    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;
     }
 
-    LayoutMultiColumnSet* lastColumnSet = lastMultiColumnSet();
-    if (!lastColumnSet) {
-        ASSERT_NOT_REACHED();
-        return true;
-    }
-    if (lastColumnSet->logicalTopInFlowThread() > offsetInFlowThread)
-        return true;
-    const MultiColumnFragmentainerGroup& lastRow = lastColumnSet->lastFragmentainerGroup();
-    if (lastRow.logicalTopInFlowThread() > offsetInFlowThread)
-        return true;
-    return offsetInFlowThread - lastRow.logicalTopInFlowThread() < lastRow.logicalHeight() * lastColumnSet->usedColumnCount();
-}
+    if (!columnSet->hasFragmentainerGroupForColumnAt(offsetInFlowThread)) {
+        LayoutMultiColumnFlowThread* enclosingFlowThread = this->enclosingFlowThread();
+        if (!enclosingFlowThread)
+            return; // Not nested. We'll never need more rows than the one we already have then.
 
-void LayoutMultiColumnFlowThread::appendNewFragmentainerGroupIfNeeded(LayoutUnit offsetInFlowThread)
-{
-    LayoutMultiColumnFlowThread* enclosingFlowThread = this->enclosingFlowThread();
-    if (!enclosingFlowThread)
-        return; // Not nested. We'll never need more rows than the one we already have then.
-    if (!hasFragmentainerGroupForColumnAt(offsetInFlowThread)) {
         // 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 = lastMultiColumnSet()->appendNewFragmentainerGroup();
+        const MultiColumnFragmentainerGroup& newRow = columnSet->appendNewFragmentainerGroup();
         enclosingFlowThread->appendNewFragmentainerGroupIfNeeded(newRow.blockOffsetInEnclosingFlowThread());
     }
 }
 
 void LayoutMultiColumnFlowThread::calculateColumnCountAndWidth(LayoutUnit& width, unsigned& count) const
 {
     LayoutBlock* columnBlock = multiColumnBlockFlow();
     const ComputedStyle* columnStyle = columnBlock->style();
     LayoutUnit availableWidth = columnBlock->contentLogicalWidth();
     LayoutUnit columnGap = columnBlock->columnGap();
@@ skipping 437 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 enclosingFlowThread() 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();
     if (!mayBeNested)
         return;
-    LayoutMultiColumnSet* columnSet = columnSetAtBlockOffset(logicalTopInFlowThreadAfterPagination);
-    if (!columnSet)
-        return;
-    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;
-    }
-    MultiColumnFragmentainerGroup& row = columnSet->fragmentainerGroupAtFlowThreadOffset(logicalTopInFlowThreadAfterPagination);
-    if (!row.isLastGroup())
-        return;
     appendNewFragmentainerGroupIfNeeded(logicalTopInFlowThreadAfterPagination);
 }
 
 }