Allow zero-height fragmentainers.

third_party/WebKit/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 70 matching lines @@
     const auto& row = m_fragmentainerGroups[index];
     if (row.logicalTop() + row.logicalHeight() > blockOffset)
       return row;
   }
   return m_fragmentainerGroups.last();
 }
 
 LayoutUnit LayoutMultiColumnSet::pageLogicalHeightForOffset(
     LayoutUnit offsetInFlowThread) const {
   const MultiColumnFragmentainerGroup& lastRow = lastFragmentainerGroup();
-  if (!lastRow.logicalHeight()) {
+  if (!lastRow.logicalHeight() && m_fragmentainerGroups.size() == 1) {
     // In the first layout pass of an auto-height multicol container, height
     // isn't set. No need to perform the series of complicated dance steps below
     // to figure out that we should simply return 0. Bail now.
-    ASSERT(m_fragmentainerGroups.size() == 1);
     return LayoutUnit();
   }
   if (offsetInFlowThread >=
       lastRow.logicalTopInFlowThread() + fragmentainerGroupCapacity(lastRow)) {
     // The offset is outside the bounds of the fragmentainer groups that we have
     // established at this point. If we're nested inside another fragmentation
     // context, we need to calculate the height on our own.
     const LayoutMultiColumnFlowThread* flowThread = multiColumnFlowThread();
     if (FragmentationContext* enclosingFragmentationContext =
             flowThread->enclosingFragmentationContext()) {
@@ skipping 24 matching lines @@
       .logicalHeight();
 }
 
 LayoutUnit LayoutMultiColumnSet::pageRemainingLogicalHeightForOffset(
     LayoutUnit offsetInFlowThread,
     PageBoundaryRule pageBoundaryRule) const {
   const MultiColumnFragmentainerGroup& row =
       fragmentainerGroupAtFlowThreadOffset(offsetInFlowThread,
                                            pageBoundaryRule);
   LayoutUnit pageLogicalHeight = row.logicalHeight();
-  // It's not allowed to call this method if the height is unknown.
-  DCHECK(pageLogicalHeight);
   LayoutUnit pageLogicalBottom =
       row.columnLogicalTopForOffset(offsetInFlowThread) + pageLogicalHeight;
   LayoutUnit remainingLogicalHeight = pageLogicalBottom - offsetInFlowThread;
 
   if (pageBoundaryRule == AssociateWithFormerPage) {
     // An offset exactly at a column boundary will act as being part of the
     // former column in question (i.e. no remaining space), rather than being
     // part of the latter (i.e. one whole column length of remaining space).
     remainingLogicalHeight = intMod(remainingLogicalHeight, pageLogicalHeight);
   } else if (!remainingLogicalHeight) {
-    // When pageBoundaryRule is AssociateWithLatterPage, we should never return
-    // 0, because if there's no space left, it means that we should be at a
+    // When pageBoundaryRule is AssociateWithLatterPage, we shouldn't just
+    // return 0 if there's no space left, because in that case we're at a
     // column boundary, in which case we should return the amount of space
-    // remaining in the *next* column. But this is not true if the offset is
-    // "infinite" (saturated), so allow this to happen in that case.
-    ASSERT(offsetInFlowThread.mightBeSaturated());
+    // remaining in the *next* column. Note that the page height itself may be
+    // 0, though.
     remainingLogicalHeight = pageLogicalHeight;
   }
   return remainingLogicalHeight;
 }
 
 bool LayoutMultiColumnSet::isPageLogicalHeightKnown() const {
   return firstFragmentainerGroup().logicalHeight();
 }
 
 bool LayoutMultiColumnSet::newFragmentainerGroupsAllowed() const {
@@ skipping 415 matching lines @@
   // Now add in column rule bounds, if present.
   Vector<LayoutRect> columnRuleBounds;
   if (computeColumnRuleBounds(LayoutPoint(), columnRuleBounds)) {
     for (auto& bound : columnRuleBounds)
       blockFlowBounds.unite(bound);
   }
   return blockFlowBounds;
 }
 
 }  // namespace blink