Move table row pagination strut insertion to 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 842 matching lines @@
 
   SpanningLayoutTableCells rowSpanCells;
 #if ENABLE(ASSERT)
   HashSet<const LayoutTableCell*> uniqueCells;
 #endif
 
   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).
       m_rowPos[r + 1] = std::max(
           m_rowPos[r] +
               minimumValueForLength(m_grid[r].logicalHeight, LayoutUnit())
                   .round(),
           0);
     } else {
       // Non-specified lengths are ignored because the row already accounts for
@@ skipping 98 matching lines @@
     }
 
     if (LayoutTableRow* rowLayoutObject = m_grid[r].rowLayoutObject) {
       if (state.isPaginated()) {
         rowLayoutObject->setLogicalTop(rowLogicalTop);
         if (!rowLayoutObject->needsLayout())
           markChildForPaginationRelayoutIfNeeded(*rowLayoutObject, layouter);
       }
       rowLayoutObject->layoutIfNeeded();
       if (state.isPaginated()) {
-        rowLayoutObject->setLogicalHeight(
-            LayoutUnit(logicalHeightForRow(*rowLayoutObject)));
+        adjustRowForPagination(*rowLayoutObject, layouter);
         rowLogicalTop = rowLayoutObject->logicalBottom();
         rowLogicalTop += LayoutUnit(table()->vBorderSpacing());
       }
     }
   }
 
   clearNeedsLayout();
 }
 
 void LayoutTableSection::distributeExtraLogicalHeightToPercentRows(
@@ skipping 118 matching lines @@
   // FIXME: Changing the height without a layout can change the overflow so it
   // seems wrong.
 
   unsigned totalRows = m_grid.size();
 
   // Set the width of our section now.  The rows will also be this width.
   setLogicalWidth(table()->contentLogicalWidth());
 
   int vspacing = table()->vBorderSpacing();
   unsigned nEffCols = table()->numEffectiveColumns();
-  bool isPaginated = view()->layoutState()->isPaginated();
-
-  if (isPaginated) {
-    LayoutTableSection* header = table()->header();
-    // If we're a table header nested inside a table cell then we want to repeat
-    // on each page, but below the header we're nested inside. Note we don't try
-    // to match the padding on the cell on each repeated header.
-    if (header && header == this)
-      setOffsetForRepeatingHeader(
-          view()->layoutState()->heightOffsetForTableHeaders());
-  }
-
   LayoutState state(*this, locationOffset());
 
+  // Set the rows' location and size.
   for (unsigned r = 0; r < totalRows; r++) {
-    // Set the row's x/y position and width/height.
     LayoutTableRow* rowLayoutObject = m_grid[r].rowLayoutObject;
-    int paginationStrutOnRow = 0;
     if (rowLayoutObject) {
       rowLayoutObject->setLogicalLocation(LayoutPoint(0, m_rowPos[r]));
       rowLayoutObject->setLogicalWidth(logicalWidth());
-      rowLayoutObject->setLogicalHeight(
-          LayoutUnit(m_rowPos[r + 1] - m_rowPos[r] - vspacing));
+      LayoutUnit rowLogicalHeight(m_rowPos[r + 1] - m_rowPos[r] - vspacing);
+      if (state.isPaginated() && r + 1 < totalRows) {
+        // If the next row has a pagination strut, we need to subtract it. It
+        // should not be included in this row's height.
+        if (LayoutTableRow* nextRowObject = m_grid[r + 1].rowLayoutObject)
+          rowLogicalHeight -= nextRowObject->paginationStrut();
+      }
+      rowLayoutObject->setLogicalHeight(rowLogicalHeight);
       rowLayoutObject->updateLayerTransformAfterLayout();
-      if (isPaginated) {
-        paginationStrutOnRow =
-            paginationStrutForRow(rowLayoutObject, LayoutUnit(m_rowPos[r]));
-        rowLayoutObject->setPaginationStrut(LayoutUnit(paginationStrutOnRow));
-        bool rowIsAtTopOfColumn =
-            state.heightOffsetForTableHeaders() &&
-            pageRemainingLogicalHeightForOffset(LayoutUnit(m_rowPos[r]),
-                                                AssociateWithLatterPage) ==
-                pageLogicalHeightForOffset(LayoutUnit(m_rowPos[r]));
-        if (paginationStrutOnRow || rowIsAtTopOfColumn) {
-          // If there isn't room for at least one content row on a page with a
-          // header group, then we won't repeat the header on each page.
-          if (!r && table()->header() &&
-              table()->sectionAbove(this) == table()->header() &&
-              table()->header()->getPaginationBreakability() != AllowAnyBreaks)
-            state.setHeightOffsetForTableHeaders(
-                state.heightOffsetForTableHeaders() -
-                table()->header()->logicalHeight());
-          // If we have a header group we will paint it at the top of each page,
-          // move the rows down to accomodate it.
-          paginationStrutOnRow += state.heightOffsetForTableHeaders().toInt();
-          for (unsigned rowIndex = r; rowIndex <= totalRows; rowIndex++)
-            m_rowPos[rowIndex] += paginationStrutOnRow;
-        }
-      }
     }
+  }
 
+  // Vertically align and flex the cells in each row.
+  for (unsigned r = 0; r < totalRows; r++) {
+    LayoutTableRow* rowLayoutObject = m_grid[r].rowLayoutObject;
     int rowHeightIncreaseForPagination = INT_MIN;
 
     for (unsigned c = 0; c < nEffCols; c++) {
       CellStruct& cs = cellAt(r, c);
       LayoutTableCell* cell = cs.primaryCell();
 
       if (!cell || cs.inColSpan)
         continue;
 
-      int rowIndex = cell->rowIndex();
-      int rHeight =
-          m_rowPos[rowIndex + cell->rowSpan()] - m_rowPos[rowIndex] - vspacing;
+      if (cell->rowIndex() != r)
+        continue;  // Rowspanned cells are handled in the first row they occur.
+
+      int rHeight;
+      int rowLogicalTop;
+      unsigned rowSpan = std::max(1U, cell->rowSpan());
+      unsigned endRowIndex = std::min(r + rowSpan, totalRows) - 1;
+      LayoutTableRow* lastRowObject = m_grid[endRowIndex].rowLayoutObject;
+      if (lastRowObject && rowLayoutObject) {
+        rowLogicalTop = rowLayoutObject->logicalTop().toInt();
+        rHeight = lastRowObject->logicalBottom().toInt() - rowLogicalTop;
+      } else {
+        rHeight = m_rowPos[endRowIndex + 1] - m_rowPos[r] - vspacing;
+        rowLogicalTop = m_rowPos[r];
+      }
 
       relayoutCellIfFlexed(*cell, r, rHeight);
 
       SubtreeLayoutScope layouter(*cell);
-      LayoutUnit rowLogicalTop(m_rowPos[rowIndex]);
       EVerticalAlign cellVerticalAlign;
       // If the cell crosses a fragmentainer boundary, just align it at the
       // top. That's how it was laid out initially, before we knew the final
       // row height, and re-aligning it now could result in the cell being
       // fragmented differently, which could change its height and thus violate
       // the requested alignment. Give up instead of risking circular
       // dependencies and unstable layout.
       if (state.isPaginated() &&
-          crossesPageBoundary(rowLogicalTop, LayoutUnit(rHeight)))
+          crossesPageBoundary(LayoutUnit(rowLogicalTop), LayoutUnit(rHeight)))
         cellVerticalAlign = VerticalAlignTop;
       else
         cellVerticalAlign = cell->style()->verticalAlign();
       cell->computeIntrinsicPadding(rHeight, cellVerticalAlign, layouter);
 
       LayoutRect oldCellRect = cell->frameRect();
 
       setLogicalPositionForCell(cell, c);
 
       if (!cell->needsLayout())
@@ skipping 783 matching lines @@
     // 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) {
       logicalHeight =
           std::max(logicalHeight, cell->logicalHeightForRowSizing());
     }
   }
   return logicalHeight;
 }
 
+void LayoutTableSection::adjustRowForPagination(LayoutTableRow& rowObject,
+                                                SubtreeLayoutScope& layouter) {
+  LayoutState& state = *view()->layoutState();
+  rowObject.setPaginationStrut(LayoutUnit());
+  rowObject.setLogicalHeight(LayoutUnit(logicalHeightForRow(rowObject)));
+  int paginationStrut =
+      paginationStrutForRow(&rowObject, rowObject.logicalTop());
+  if (!paginationStrut) {
+    bool rowIsAtTopOfColumn =
+        state.heightOffsetForTableHeaders() &&
+        pageLogicalHeightForOffset(rowObject.logicalTop()) ==
+            pageRemainingLogicalHeightForOffset(rowObject.logicalTop(),
+                                                AssociateWithLatterPage);
+    if (!rowIsAtTopOfColumn)
+      return;
+  }
+  // We need to push this row to the next fragmentainer. If there are repeated
+  // table headers, we need to make room for those at the top of the next
+  // fragmentainer, above this row. Otherwise, this row will just go at the top
+  // of the next fragmentainer.
+
+  // If there isn't room for at least one content row on a page with a
+  // header group, then we won't repeat the header on each page.
+  LayoutTableSection* header = table()->header();
+  if (!rowObject.rowIndex() && header &&
+      table()->sectionAbove(this) == header &&
+      header->getPaginationBreakability() != AllowAnyBreaks) {
+    state.setHeightOffsetForTableHeaders(state.heightOffsetForTableHeaders() -
+                                         header->logicalHeight());
+  }
+  // If we have a header group we will paint it at the top of each page,
+  // move the rows down to accomodate it.
+  paginationStrut += state.heightOffsetForTableHeaders().toInt();
+  rowObject.setPaginationStrut(LayoutUnit(paginationStrut));
+
+  // We have inserted a pagination strut before the row. Adjust the logical top
+  // and re-lay out. We no longer want to break inside the row, but rather
+  // *before* it. From the previous layout pass, there are most likely
+  // pagination struts inside some cell in this row that we need to get rid of.
+  rowObject.setLogicalTop(rowObject.logicalTop() + paginationStrut);
+  layouter.setChildNeedsLayout(&rowObject);
+  rowObject.layoutIfNeeded();
+
+  // It's very likely that re-laying out (and nuking pagination struts inside
+  // cells) gave us a new height.
+  rowObject.setLogicalHeight(LayoutUnit(logicalHeightForRow(rowObject)));
+}
+
 bool LayoutTableSection::isRepeatingHeaderGroup() const {
   if (getPaginationBreakability() == LayoutBox::AllowAnyBreaks)
     return false;
   // TODO(rhogan): Should we paint a header repeatedly if it's self-painting?
   if (hasSelfPaintingLayer())
     return false;
   LayoutUnit pageHeight = table()->pageLogicalHeightForOffset(LayoutUnit());
   if (!pageHeight)
     return false;
 
@@ skipping 23 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