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 46 matching lines @@
     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()))
+                || (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 231 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())

[dgrogan, 2016/08/26 00:27:18]

This is the only change tested by the layout test.

             totalPercent += m_grid[r].logicalHeight.percent();
     }
 
     int remainingExtraLogicalHeight = extraLogicalHeight;
     distributeExtraLogicalHeightToPercentRows(remainingExtraLogicalHeight, totalPercent);
     distributeExtraLogicalHeightToAutoRows(remainingExtraLogicalHeight, autoRowsCount);
     distributeRemainingExtraLogicalHeight(remainingExtraLogicalHeight);
     return extraLogicalHeight - remainingExtraLogicalHeight;
 }
 
@@ skipping 791 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