Set logical top and height of table rows and 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 925 matching lines @@
   ASSERT(!table()->needsSectionRecalc());
 
   // addChild may over-grow m_grid but we don't want to throw away the memory
   // too early as addChild can be called in a loop (e.g during parsing). Doing
   // it now ensures we have a stable-enough structure.
   m_grid.shrinkToFit();
 
   LayoutState state(*this, locationOffset());
 
   const Vector<int>& columnPos = table()->effectiveColumnPositions();
+  LayoutUnit rowLogicalTop;
 
   SubtreeLayoutScope layouter(*this);
   for (unsigned r = 0; r < m_grid.size(); ++r) {
     Row& row = m_grid[r].row;
     unsigned cols = row.size();
     // First, propagate our table layout's information to the cells. This will
     // mark the row as needing layout if there was a column logical width
     // change.
     for (unsigned startColumn = 0; startColumn < cols; ++startColumn) {
       CellStruct& current = row[startColumn];
       LayoutTableCell* cell = current.primaryCell();
       if (!cell || current.inColSpan)
         continue;
 
       unsigned endCol = startColumn;
       unsigned cspan = cell->colSpan();
       while (cspan && endCol < cols) {
         ASSERT(endCol < table()->effectiveColumns().size());
         cspan -= table()->effectiveColumns()[endCol].span;
         endCol++;
       }
       int tableLayoutLogicalWidth = columnPos[endCol] - columnPos[startColumn] -
                                     table()->hBorderSpacing();
       cell->setCellLogicalWidth(tableLayoutLogicalWidth, layouter);
     }
 
     if (LayoutTableRow* rowLayoutObject = m_grid[r].rowLayoutObject) {
-      if (!rowLayoutObject->needsLayout())
-        markChildForPaginationRelayoutIfNeeded(*rowLayoutObject, layouter);
+      if (state.isPaginated()) {
+        rowLayoutObject->setLogicalTop(rowLogicalTop);
+        if (!rowLayoutObject->needsLayout())
+          markChildForPaginationRelayoutIfNeeded(*rowLayoutObject, layouter);
+      }
       rowLayoutObject->layoutIfNeeded();
+      if (state.isPaginated()) {
+        rowLayoutObject->setLogicalHeight(
+            LayoutUnit(logicalHeightForRow(*rowLayoutObject)));
+        rowLogicalTop = rowLayoutObject->logicalBottom();
+        rowLogicalTop += LayoutUnit(table()->vBorderSpacing());
+      }
     }
   }
 
   clearNeedsLayout();
 }
 
 void LayoutTableSection::distributeExtraLogicalHeightToPercentRows(
     int& extraLogicalHeight,
     int totalPercent) {
   if (!totalPercent)
@@ skipping 982 matching lines @@
 
   // If the baseline moved, we may have to update the data for our row. Find
   // out the new baseline.
   if (cell.isBaselineAligned()) {
     int baseline = cell.cellBaselinePosition();
     if (baseline > cell.borderBefore() + cell.paddingBefore())
       m_grid[rowIndex].baseline = std::max(m_grid[rowIndex].baseline, baseline);
   }
 }
 
+int LayoutTableSection::logicalHeightForRow(
+    const LayoutTableRow& rowObject) const {
+  unsigned rowIndex = rowObject.rowIndex();
+  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) {
+      logicalHeight =
+          std::max(logicalHeight, cell->logicalHeightForRowSizing());
+    }
+  }
+  return logicalHeight;
+}
+
 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