Respect break-inside:avoid on table rows

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)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 938 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();
 
     LayoutState state(*this, locationOffset());
 
     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->setLocation(LayoutPoint(0, m_rowPos[r]));
             rowLayoutObject->setLogicalWidth(logicalWidth());
             rowLayoutObject->setLogicalHeight(LayoutUnit(m_rowPos[r + 1] - m_rowPos[r] - vspacing));
             rowLayoutObject->updateLayerTransformAfterLayout();
+            if (isPaginated) {
+                paginationStrutOnRow = paginationStrutForRow(rowLayoutObject, LayoutUnit(m_rowPos[r]));
+                if (paginationStrutOnRow) {
+                    for (unsigned rowIndex = r; rowIndex <= totalRows; rowIndex++)
+                        m_rowPos[rowIndex] += paginationStrutOnRow;
+                }
+            }
         }
 
-        int rowHeightIncreaseForPagination = 0;
+        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;
@@ skipping 61 matching lines @@
                 cell->markForPaginationRelayoutIfNeeded(layouter);
 
             cell->layoutIfNeeded();
 
             // FIXME: Make pagination work with vertical tables.
             if (view()->layoutState()->pageLogicalHeight() && cell->logicalHeight() != rHeight) {
                 // FIXME: Pagination might have made us change size. For now just shrink or grow the cell to fit without doing a relayout.
                 // We'll also do a basic increase of the row height to accommodate the cell if it's bigger, but this isn't quite right
                 // either. It's at least stable though and won't result in an infinite # of relayouts that may never stabilize.
                 LayoutUnit oldLogicalHeight = cell->logicalHeight();
-                if (oldLogicalHeight > rHeight)
-                    rowHeightIncreaseForPagination = std::max<int>(rowHeightIncreaseForPagination, oldLogicalHeight - rHeight);
+                rowHeightIncreaseForPagination = std::max<int>(rowHeightIncreaseForPagination, oldLogicalHeight - rHeight);

[mstensho (USE GERRIT), 2016/05/04 20:23:44]

This is new. What is it for? Looks like you want to allow the row height to
shrink?

[rhogan, 2016/05/04 20:31:45]

This is per your comment: " When paginationStrutForRow() gives us something
there, we should lay out all affected cells over again, and pay attention if
their heights change. Cell heights will typically shrink, since there'll
typically be fewer pagination struts inside. This height decrease needs to be
propagated to all consecutive rows."

That's what I'm doing here.

[mstensho (USE GERRIT), 2016/05/04 21:02:23]

Oh, I said that? Indeed I did. Well, can't argue with myself, can I? :)

                 cell->setLogicalHeight(LayoutUnit(rHeight));
                 cell->computeOverflow(oldLogicalHeight, false);
             }
 
             LayoutSize childOffset(cell->location() - oldCellRect.location());
             if (childOffset.width() || childOffset.height()) {
                 // If the child moved, we have to issue paint invalidations to it as well as any floating/positioned
                 // descendants. An exception is if we need a layout. In this case, we know we're going to
                 // issue paint invalidations ourselves (and the child) anyway.
                 if (!table()->selfNeedsLayout())
                     cell->setMayNeedPaintInvalidation();
             }
         }
-        if (rowHeightIncreaseForPagination) {
+        if (rowHeightIncreaseForPagination > INT_MIN) {
             for (unsigned rowIndex = r + 1; rowIndex <= totalRows; rowIndex++)
                 m_rowPos[rowIndex] += rowHeightIncreaseForPagination;
             for (unsigned c = 0; c < nEffCols; ++c) {
                 Vector<LayoutTableCell*, 1>& cells = cellAt(r, c).cells;
                 for (size_t i = 0; i < cells.size(); ++i) {
                     LayoutUnit oldLogicalHeight = cells[i]->logicalHeight();
                     cells[i]->setLogicalHeight(oldLogicalHeight + rowHeightIncreaseForPagination);
                     cells[i]->computeOverflow(oldLogicalHeight, false);
                 }
             }
         }
         if (rowLayoutObject)
             rowLayoutObject->computeOverflow();
     }
 
     ASSERT(!needsLayout());
 
     setLogicalHeight(LayoutUnit(m_rowPos[totalRows]));
 
     computeOverflowFromCells(totalRows, nEffCols);
 }
 
+int LayoutTableSection::paginationStrutForRow(LayoutTableRow* row, LayoutUnit logicalOffset) const
+{
+    if (row->getPaginationBreakability() == AllowAnyBreaks)
+        return 0;
+    LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
+    if (!pageLogicalHeight)
+        return 0;
+    // If the row is too tall for the page don't insert a strut.
+    LayoutUnit rowLogicalHeight = row->logicalHeight();
+    if (rowLogicalHeight > pageLogicalHeight)
+        return 0;
+    LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(logicalOffset, LayoutBlock::AssociateWithLatterPage);
+    if (remainingLogicalHeight >= rowLogicalHeight)
+        return 0; // It fits fine where it is. No need to break.
+    LayoutUnit paginationStrut = calculatePaginationStrutToFitContent(logicalOffset, remainingLogicalHeight, rowLogicalHeight);
+    if (paginationStrut == remainingLogicalHeight && remainingLogicalHeight == pageLogicalHeight) {
+        // Don't break if we were at the top of a page, and we failed to fit the content
+        // completely. No point in leaving a page completely blank.
+        return 0;
+    }
+    return paginationStrut;
+}
+
 void LayoutTableSection::computeOverflowFromCells()
 {
     unsigned totalRows = m_grid.size();
     unsigned nEffCols = table()->numEffectiveColumns();
     computeOverflowFromCells(totalRows, nEffCols);
 }
 
 void LayoutTableSection::computeOverflowFromCells(unsigned totalRows, unsigned nEffCols)
 {
     unsigned totalCellsCount = nEffCols * totalRows;
@@ skipping 566 matching lines @@
     // FIXME: The table's direction should determine our row's direction, not the section's (see bug 96691).
     if (!style()->isLeftToRightDirection())
         cellLocation.setX(LayoutUnit(table()->effectiveColumnPositions()[table()->numEffectiveColumns()] - table()->effectiveColumnPositions()[table()->absoluteColumnToEffectiveColumn(cell->absoluteColumnIndex() + cell->colSpan())] + horizontalBorderSpacing));
     else
         cellLocation.setX(LayoutUnit(table()->effectiveColumnPositions()[effectiveColumn] + horizontalBorderSpacing));
 
     cell->setLogicalLocation(cellLocation);
 }
 
 } // namespace blink