Need to examine the *bottom* of fragmented content.

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 434 matching lines @@
     return nullptr;
 }
 
 FragmentationContext* LayoutMultiColumnFlowThread::enclosingFragmentationContext() const
 {
     if (LayoutMultiColumnFlowThread* enclosingFlowThread = this->enclosingFlowThread())
         return enclosingFlowThread;
     return view()->fragmentationContext();
 }
 
-void LayoutMultiColumnFlowThread::appendNewFragmentainerGroupIfNeeded(LayoutUnit offsetInFlowThread)
+void LayoutMultiColumnFlowThread::appendNewFragmentainerGroupIfNeeded(LayoutUnit bottomOffsetInFlowThread)
 {
     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;
     }
-    LayoutMultiColumnSet* columnSet = columnSetAtBlockOffset(offsetInFlowThread);
+    // 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);
     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(offsetInFlowThread)) {
+    if (!columnSet->hasFragmentainerGroupForColumnAt(bottomOffsetInFlowThread)) {
         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());
+            enclosingFlowThread->appendNewFragmentainerGroupIfNeeded(newRow.blockOffsetInEnclosingFragmentationContext() + newRow.logicalHeight());
     }
 }
 
 bool LayoutMultiColumnFlowThread::isFragmentainerLogicalHeightKnown()
 {
     return isPageLogicalHeightKnown();
 }
 
 LayoutUnit LayoutMultiColumnFlowThread::fragmentainerLogicalHeightAt(LayoutUnit blockOffset)
 {
@@ skipping 435 matching lines @@
             // remaining in the currently last row.
             LayoutRect layoutRect = layoutOverflowRect();
             LayoutUnit logicalBottomInFlowThread = isHorizontalWritingMode() ? layoutRect.maxY() : layoutRect.maxX();
             ASSERT(logicalBottomInFlowThread >= logicalHeight());
             lastSet->endFlow(logicalBottomInFlowThread);
         }
     }
     m_lastSetWorkedOn = nullptr;
 }
 
-void LayoutMultiColumnFlowThread::contentWasLaidOut(LayoutUnit logicalTopInFlowThreadAfterPagination)
+void LayoutMultiColumnFlowThread::contentWasLaidOut(LayoutUnit logicalBottomInFlowThreadAfterPagination)
 {
     // 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.
 
     // 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(logicalTopInFlowThreadAfterPagination);
+    appendNewFragmentainerGroupIfNeeded(logicalBottomInFlowThreadAfterPagination);
 }
 
 }