Pay attention to tall rowspanned cells in the first layout pass.

third_party/WebKit/Source/core/layout/LayoutTableSection.cpp

 /*
  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
  *           (C) 1997 Torben Weis (weis@kde.org)
  *           (C) 1998 Waldo Bastian (bastian@kde.org)
  *           (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 838 matching lines @@
   if (this == table()->topSection())
     m_rowPos[0] = table()->vBorderSpacing();
   else
     m_rowPos[0] = 0;
 
   SpanningLayoutTableCells rowSpanCells;
 #if ENABLE(ASSERT)
   HashSet<const LayoutTableCell*> uniqueCells;
 #endif
 
+  // At fragmentainer breaks we need to prevent rowspanned cells (and whatever
+  // else) from distributing their extra height requirements over the rows that
+  // it spans. Otherwise we'd need to refragment afterwards.
+  unsigned indexOfFirstStretchableRow = 0;
+
   for (unsigned r = 0; r < m_grid.size(); r++) {
     m_grid[r].baseline = -1;
     int baselineDescent = 0;
 
     if (state.isPaginated() && m_grid[r].rowLayoutObject)
       m_rowPos[r] += m_grid[r].rowLayoutObject->paginationStrut().ceil();
 
     if (m_grid[r].logicalHeight.isSpecified()) {
       // Our base size is the biggest logical height from our cells' styles
       // (excluding row spanning cells).
@@ skipping 12 matching lines @@
     unsigned totalCols = row.size();
     LayoutTableCell* lastRowSpanCell = nullptr;
 
     for (unsigned c = 0; c < totalCols; c++) {
       CellStruct& current = cellAt(r, c);
       for (unsigned i = 0; i < current.cells.size(); i++) {
         cell = current.cells[i];
         if (current.inColSpan && cell->rowSpan() == 1)
           continue;
 
-        if (cell->rowSpan() > 1) {
+        if (r < indexOfFirstStretchableRow ||
+            (state.isPaginated() &&
+             crossesPageBoundary(
+                 LayoutUnit(m_rowPos[cell->rowIndex()]),
+                 LayoutUnit(cell->logicalHeightForRowSizing())))) {
+          // Entering or extending a range of unstretchable rows. We enter this
+          // mode when a cell in a row crosses a fragmentainer boundary, and
+          // we'll stay in this mode until we get to a row where we're past all
+          // rowspanned cells that we encountered while in this mode.
+          DCHECK(state.isPaginated());
+          unsigned rowIndexBelowCell = cell->rowIndex() + cell->rowSpan();
+          indexOfFirstStretchableRow =
+              std::max(indexOfFirstStretchableRow, rowIndexBelowCell);
+        } else if (cell->rowSpan() > 1) {
           // For row spanning cells, we only handle them for the first row they
           // span. This ensures we take their baseline into account.
           if (lastRowSpanCell != cell && cell->rowIndex() == r) {
 #if ENABLE(ASSERT)
             ASSERT(!uniqueCells.contains(cell));
             uniqueCells.add(cell);
 #endif
 
             rowSpanCells.append(cell);
             lastRowSpanCell = cell;
@@ skipping 10 matching lines @@
           m_rowPos[r + 1] = std::max(
               m_rowPos[r + 1], m_rowPos[r] + cell->logicalHeightForRowSizing());
 
         // Find out the baseline. The baseline is set on the first row in a
         // rowSpan.
         if (cell->rowIndex() == r)
           updateBaselineForCell(cell, r, baselineDescent);
       }
     }
 
+    if (r < indexOfFirstStretchableRow && m_grid[r].rowLayoutObject) {
+      // We're not allowed to resize this row. Just scratch what we've
+      // calculated so far, and use the height that we got during initial
+      // layout instead.
+      m_rowPos[r + 1] =
+          m_rowPos[r] + m_grid[r].rowLayoutObject->logicalHeight().toInt();
+    }
+
     // Add the border-spacing to our final position.
     m_rowPos[r + 1] += borderSpacingForRow(r);
     m_rowPos[r + 1] = std::max(m_rowPos[r + 1], m_rowPos[r]);
   }
 
   if (!rowSpanCells.isEmpty())
     distributeRowSpanHeightToRows(rowSpanCells);
 
   ASSERT(!needsLayout());
 
@@ skipping 1035 matching lines @@
   unsigned rowIndex = rowObject.rowIndex();
   DCHECK(rowIndex < m_grid.size());
   int logicalHeight = 0;
   const Row& row = m_grid[rowIndex].row;
   unsigned cols = row.size();
   for (unsigned colIndex = 0; colIndex < cols; colIndex++) {
     const CellStruct& cellStruct = cellAt(rowIndex, colIndex);
     const LayoutTableCell* cell = cellStruct.primaryCell();
     if (!cell || cellStruct.inColSpan)
       continue;
-    // TODO(mstensho): Rowspanned cells also need to contribute to row heights
-    // during the first layout pass, in order to get fragmentation right.
-    if (cell->rowSpan() == 1) {
+    unsigned rowSpan = cell->rowSpan();
+    if (rowSpan == 1) {
       logicalHeight =
           std::max(logicalHeight, cell->logicalHeightForRowSizing());
+      continue;
+    }
+    unsigned rowIndexForCell = cell->rowIndex();
+    if (rowIndex == m_grid.size() - 1 ||
+        (rowSpan > 1 && rowIndex - rowIndexForCell == rowSpan - 1)) {
+      // This is the last row of the rowspanned cell. Add extra height if
+      // needed.
+      if (LayoutTableRow* firstRowForCell =
+              m_grid[rowIndexForCell].rowLayoutObject) {
+        int rowLogicalTop = rowObject.logicalTop().round();
+
+        int minLogicalHeight = cell->logicalHeightForRowSizing();
+        // Subtract space provided by previous rows.
+        minLogicalHeight -=
+            rowLogicalTop - firstRowForCell->logicalTop().toInt();

[eae, 2016/10/20 16:53:58]

Above you round the logicalTop and here you floor it. Given that all are ints it
probably doesn't matter much but it seems wrong to me.

[mstensho (USE GERRIT), 2016/10/20 19:05:56]

Better use toInt() everywhere, unless there are good reasons not to.

Done.

+
+        logicalHeight = std::max(logicalHeight, minLogicalHeight);
+      }
     }
   }
 
   if (m_grid[rowIndex].logicalHeight.isSpecified()) {
     LayoutUnit specifiedLogicalHeight =
         minimumValueForLength(m_grid[rowIndex].logicalHeight, LayoutUnit());
     logicalHeight = std::max(logicalHeight, specifiedLogicalHeight.toInt());
   }
   return logicalHeight;
 }
@@ skipping 82 matching lines @@
   // the header in all columns.
   // Note that this is in flow thread coordinates, not visual coordinates. The
   // enclosing LayoutFlowThread will convert to visual coordinates.
   if (table()->header() == this && isRepeatingHeaderGroup())
     rect.setHeight(table()->logicalHeight());
   return LayoutTableBoxComponent::mapToVisualRectInAncestorSpace(ancestor, rect,
                                                                  flags);
 }
 
 }  // namespace blink