Move table cell height flexing into a separate method.

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 1115 matching lines @@
       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;
 
-      // Force percent height children to lay themselves out again.
-      // This will cause these children to grow to fill the cell.
-      // FIXME: There is still more work to do here to fully match WinIE (should
-      // it become necessary to do so).  In quirks mode, WinIE behaves like we
-      // do, but it will clip the cells that spill out of the table section.  In
-      // strict mode, Mozilla and WinIE both regrow the table to accommodate the
-      // new height of the cell (thus letting the percentages cause growth one
-      // time only).  We may also not be handling row-spanning cells correctly.
-      //
-      // Note also the oddity where replaced elements always flex, and yet blocks/tables do
-      // not necessarily flex.  WinIE is crazy and inconsistent, and we can't hope to
-      // match the behavior perfectly, but we'll continue to refine it as we discover new
-      // bugs. :)
-      bool cellChildrenFlex = false;
-      bool flexAllChildren = cell->style()->logicalHeight().isFixed() ||
-                             (!table()->style()->logicalHeight().isAuto() &&
-                              rHeight != cell->logicalHeight());
-
-      for (LayoutObject* child = cell->firstChild(); child;
-           child = child->nextSibling()) {
-        if (!child->isText() &&
-            child->style()->logicalHeight().isPercentOrCalc() &&
-            (flexAllChildren || shouldFlexCellChild(child)) &&
-            (!child->isTable() || toLayoutTable(child)->hasSections())) {
-          cellChildrenFlex = true;
-          break;
-        }
-      }
-
-      if (!cellChildrenFlex) {
-        if (TrackedLayoutBoxListHashSet* percentHeightDescendants =
-                cell->percentHeightDescendants()) {
-          for (auto* descendant : *percentHeightDescendants) {
-            if (flexAllChildren || shouldFlexCellChild(descendant)) {
-              cellChildrenFlex = true;
-              break;
-            }
-          }
-        }
-      }
-
-      if (cellChildrenFlex) {
-        // Alignment within a cell is based off the calculated
-        // height, which becomes irrelevant once the cell has
-        // been resized based off its percentage.
-        cell->setOverrideLogicalContentHeightFromRowHeight(LayoutUnit(rHeight));
-        cell->forceChildLayout();
-
-        // 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[r].baseline = std::max(m_grid[r].baseline, baseline);
-        }
-      }
+      relayoutCellIfFlexed(*cell, r, rHeight);
 
       SubtreeLayoutScope layouter(*cell);
       cell->computeIntrinsicPadding(rHeight, layouter);
 
       LayoutRect oldCellRect = cell->frameRect();
 
       setLogicalPositionForCell(cell, c);
 
       if (!cell->needsLayout())
         markChildForPaginationRelayoutIfNeeded(*cell, layouter);
@@ skipping 692 matching lines @@
                 cell->absoluteColumnIndex() + cell->colSpan())] +
         horizontalBorderSpacing));
   else
     cellLocation.setX(
         LayoutUnit(table()->effectiveColumnPositions()[effectiveColumn] +
                    horizontalBorderSpacing));
 
   cell->setLogicalLocation(cellLocation);
 }
 
+void LayoutTableSection::relayoutCellIfFlexed(LayoutTableCell& cell,
+                                              int rowIndex,
+                                              int rowHeight) {
+  // Force percent height children to lay themselves out again.
+  // This will cause these children to grow to fill the cell.
+  // FIXME: There is still more work to do here to fully match WinIE (should
+  // it become necessary to do so).  In quirks mode, WinIE behaves like we
+  // do, but it will clip the cells that spill out of the table section.  In
+  // strict mode, Mozilla and WinIE both regrow the table to accommodate the
+  // new height of the cell (thus letting the percentages cause growth one
+  // time only).  We may also not be handling row-spanning cells correctly.
+  //
+  // Note also the oddity where replaced elements always flex, and yet
+  // blocks/tables do not necessarily flex. WinIE is crazy and inconsistent,
+  // and we can't hope to match the behavior perfectly, but we'll continue to
+  // refine it as we discover new bugs. :)
+  bool cellChildrenFlex = false;
+  bool flexAllChildren = cell.style()->logicalHeight().isFixed() ||
+                         (!table()->style()->logicalHeight().isAuto() &&
+                          rowHeight != cell.logicalHeight());
+
+  for (LayoutObject* child = cell.firstChild(); child;
+       child = child->nextSibling()) {
+    if (!child->isText() && child->style()->logicalHeight().isPercentOrCalc() &&
+        (flexAllChildren || shouldFlexCellChild(child)) &&
+        (!child->isTable() || toLayoutTable(child)->hasSections())) {
+      cellChildrenFlex = true;
+      break;
+    }
+  }
+
+  if (!cellChildrenFlex) {
+    if (TrackedLayoutBoxListHashSet* percentHeightDescendants =
+            cell.percentHeightDescendants()) {
+      for (auto* descendant : *percentHeightDescendants) {
+        if (flexAllChildren || shouldFlexCellChild(descendant)) {
+          cellChildrenFlex = true;
+          break;
+        }
+      }
+    }
+  }
+
+  if (!cellChildrenFlex)
+    return;
+
+  // Alignment within a cell is based off the calculated height, which becomes
+  // irrelevant once the cell has been resized based off its percentage.
+  cell.setOverrideLogicalContentHeightFromRowHeight(LayoutUnit(rowHeight));
+  cell.forceChildLayout();
+
+  // 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);
+  }
+}
+
 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 19 matching lines @@
   // Repeating table headers are painted once per fragmentation page/column. This does not go through the regular fragmentation machinery,
   // so we need special code to expand the invalidation rect to contain all positions of 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