Add Length::isPercent and use it in tables.

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 45 matching lines @@
     // We ignore height settings on rowspan cells.
     if (cell->rowSpan() != 1)
         return;
 
     Length logicalHeight = cell->style()->logicalHeight();
     if (logicalHeight.isPositive()) {
         Length cRowLogicalHeight = row.logicalHeight;
         switch (logicalHeight.type()) {
         case Percent:
             // TODO(alancutter): Make this work correctly for calc lengths.
-            if (!(cRowLogicalHeight.hasPercent())
-                || (cRowLogicalHeight.hasPercent() && cRowLogicalHeight.percent() < logicalHeight.percent()))
+            if (!(cRowLogicalHeight.isPercentOrCalc())
+                || (cRowLogicalHeight.isPercent() && cRowLogicalHeight.percent() < logicalHeight.percent()))
                 row.logicalHeight = logicalHeight;
             break;
         case Fixed:
             if (cRowLogicalHeight.type() < Percent
                 || (cRowLogicalHeight.isFixed() && cRowLogicalHeight.value() < logicalHeight.value()))
                 row.logicalHeight = logicalHeight;
             break;
         default:
             break;
         }
@@ skipping 281 matching lines @@
     const unsigned rowIndex = cell->rowIndex();
     float percent = std::min(totalPercent, 100.0f);
     const int tableHeight = m_rowPos[m_grid.size()] + extraRowSpanningHeight;
 
     // Our algorithm matches Firefox. Extra spanning height would be distributed Only in first percent height rows
     // those total percent is 100. Other percent rows would be uneffected even extra spanning height is remain.
     int accumulatedPositionIncrease = 0;
     for (unsigned row = rowIndex; row < (rowIndex + rowSpan); row++) {
         if (percent > 0 && extraRowSpanningHeight > 0) {
             // TODO(alancutter): Make this work correctly for calc lengths.
-            if (m_grid[row].logicalHeight.hasPercent()) {
+            if (m_grid[row].logicalHeight.isPercent()) {
                 int toAdd = (tableHeight * std::min(m_grid[row].logicalHeight.percent(), percent) / 100) - rowsHeight[row - rowIndex];
 
                 toAdd = std::max(std::min(toAdd, extraRowSpanningHeight), 0);
                 accumulatedPositionIncrease += toAdd;
                 extraRowSpanningHeight -= toAdd;
                 percent -= m_grid[row].logicalHeight.percent();
             }
         }
         m_rowPos[row + 1] += accumulatedPositionIncrease;
     }
@@ skipping 22 matching lines @@
     if (!extraRowSpanningHeight || !totalPercent)
         return;
 
     const unsigned rowSpan = cell->rowSpan();
     const unsigned rowIndex = cell->rowIndex();
     double remainder = 0;
 
     int accumulatedPositionIncrease = 0;
     for (unsigned row = rowIndex; row < (rowIndex + rowSpan); row++) {
         // TODO(alancutter): Make this work correctly for calc lengths.
-        if (m_grid[row].logicalHeight.hasPercent()) {
+        if (m_grid[row].logicalHeight.isPercent()) {
             updatePositionIncreasedWithRowHeight(extraRowSpanningHeight, m_grid[row].logicalHeight.percent(), totalPercent, accumulatedPositionIncrease, remainder);
         }
         m_rowPos[row + 1] += accumulatedPositionIncrease;
     }
 
     DCHECK(!round(remainder)) << "remainder was " << remainder;
 
     extraRowSpanningHeight -= accumulatedPositionIncrease;
 }
 
@@ skipping 27 matching lines @@
         return;
 
     const unsigned rowSpan = cell->rowSpan();
     const unsigned rowIndex = cell->rowIndex();
     int accumulatedPositionIncrease = 0;
     double remainder = 0;
 
     // Aspect ratios of the rows should not change otherwise table may look different than user expected.
     // So extra height distribution in remaining spanning rows based on their weight in spanning cell.
     for (unsigned row = rowIndex; row < (rowIndex + rowSpan); row++) {
-        if (!m_grid[row].logicalHeight.hasPercent()) {
+        if (!m_grid[row].logicalHeight.isPercentOrCalc()) {
             updatePositionIncreasedWithRowHeight(extraRowSpanningHeight, rowsHeight[row - rowIndex], totalRemainingRowsHeight, accumulatedPositionIncrease, remainder);
         }
         m_rowPos[row + 1] += accumulatedPositionIncrease;
     }
 
     DCHECK(!round(remainder)) << "remainder was " << remainder;
 
     extraRowSpanningHeight -= accumulatedPositionIncrease;
 }
 
@@ skipping 183 matching lines @@
         float totalPercent = 0;
         int totalAutoRowsHeight = 0;
         int totalRemainingRowsHeight = spanningRowsHeight.totalRowsHeight;
 
         // FIXME: Inner spanning cell height should not change if it have fixed height when it's parent spanning cell
         // is distributing it's extra height in rows.
 
         // Calculate total percentage, total auto rows height and total rows height except percent rows.
         for (unsigned row = rowIndex; row < spanningCellEndIndex; row++) {
             // TODO(alancutter): Make this work correctly for calc lengths.
-            if (m_grid[row].logicalHeight.hasPercent()) {
+            if (m_grid[row].logicalHeight.isPercent()) {
                 totalPercent += m_grid[row].logicalHeight.percent();
                 totalRemainingRowsHeight -= spanningRowsHeight.rowHeight[row - rowIndex];
             } else if (m_grid[row].logicalHeight.isAuto()) {
                 totalAutoRowsHeight += spanningRowsHeight.rowHeight[row - rowIndex];
             }
         }
 
         int extraRowSpanningHeight = spanningRowsHeight.spanningCellHeightIgnoringBorderSpacing - spanningRowsHeight.totalRowsHeight;
 
         if (totalPercent < 100 && !totalAutoRowsHeight && !totalRemainingRowsHeight) {
@@ skipping 187 matching lines @@
     if (!totalPercent)
         return;
 
     unsigned totalRows = m_grid.size();
     int totalHeight = m_rowPos[totalRows] + extraLogicalHeight;
     int totalLogicalHeightAdded = 0;
     totalPercent = std::min(totalPercent, 100);
     int rowHeight = m_rowPos[1] - m_rowPos[0];
     for (unsigned r = 0; r < totalRows; ++r) {
         // TODO(alancutter): Make this work correctly for calc lengths.
-        if (totalPercent > 0 && m_grid[r].logicalHeight.hasPercent()) {
+        if (totalPercent > 0 && m_grid[r].logicalHeight.isPercent()) {
             int toAdd = std::min<int>(extraLogicalHeight, (totalHeight * m_grid[r].logicalHeight.percent() / 100) - rowHeight);
             // If toAdd is negative, then we don't want to shrink the row (this bug
             // affected Outlook Web Access).
             toAdd = std::max(0, toAdd);
             totalLogicalHeightAdded += toAdd;
             extraLogicalHeight -= toAdd;
             totalPercent -= m_grid[r].logicalHeight.percent();
         }
         ASSERT(totalRows >= 1);
         if (r < totalRows - 1)
@@ skipping 51 matching lines @@
         return extraLogicalHeight;
 
     if (!m_rowPos[totalRows] && nextSibling())
         return extraLogicalHeight;
 
     unsigned autoRowsCount = 0;
     int totalPercent = 0;
     for (unsigned r = 0; r < totalRows; r++) {
         if (m_grid[r].logicalHeight.isAuto())
             ++autoRowsCount;
-        else if (m_grid[r].logicalHeight.hasPercent())
+        else if (m_grid[r].logicalHeight.isPercent())
             totalPercent += m_grid[r].logicalHeight.percent();
     }
 
     int remainingExtraLogicalHeight = extraLogicalHeight;
     distributeExtraLogicalHeightToPercentRows(remainingExtraLogicalHeight, totalPercent);
     distributeExtraLogicalHeightToAutoRows(remainingExtraLogicalHeight, autoRowsCount);
     distributeRemainingExtraLogicalHeight(remainingExtraLogicalHeight);
     return extraLogicalHeight - remainingExtraLogicalHeight;
 }
 
@@ skipping 82 matching lines @@
             //
             // 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().hasPercent()
+                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) {
@@ skipping 688 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 && hasRepeatingHeaderGroup())
         rect.setHeight(table()->logicalHeight());
     return LayoutTableBoxComponent::mapToVisualRectInAncestorSpace(ancestor, rect, flags);
 }
 
 
 } // namespace blink