Add Length::isPercent and use it in tables.

third_party/WebKit/Source/core/layout/TableLayoutAlgorithmAuto.cpp

 /*
  * Copyright (C) 2002 Lars Knoll (knoll@kde.org)
  *           (C) 2002 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2008, 2010 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License.
  *
@@ skipping 72 matching lines @@
                     // FIXME: calc() on tables should be handled consistently with other lengths. See bug: https://crbug.com/382725
                     if (cellLogicalWidth.isCalculated())
                         cellLogicalWidth = Length(); // Make it Auto
                     if (cellLogicalWidth.value() > cCellMaxWidth)
                         cellLogicalWidth.setValue(cCellMaxWidth);
                     if (cellLogicalWidth.isNegative())
                         cellLogicalWidth.setValue(0);
                     switch (cellLogicalWidth.type()) {
                     case Fixed:
                         // ignore width=0
-                        if (cellLogicalWidth.isPositive() && !columnLayout.logicalWidth.hasPercent()) {
+                        if (cellLogicalWidth.isPositive() && !columnLayout.logicalWidth.isPercentOrCalc()) {
                             int logicalWidth = cell->adjustBorderBoxLogicalWidthForBoxSizing(cellLogicalWidth.value()).toInt();
                             if (columnLayout.logicalWidth.isFixed()) {
                                 // Nav/IE weirdness
                                 if ((logicalWidth > columnLayout.logicalWidth.value())
                                     || ((columnLayout.logicalWidth.value() == logicalWidth) && (maxContributor == cell))) {
                                     columnLayout.logicalWidth.setValue(Fixed, logicalWidth);
                                     fixedContributor = cell;
                                 }
                             } else {
                                 columnLayout.logicalWidth.setValue(Fixed, logicalWidth);
                                 fixedContributor = cell;
                             }
                         }
                         break;
                     case Percent:
                         m_hasPercent = true;
                         // TODO(alancutter): Make this work correctly for calc lengths.
-                        if (cellLogicalWidth.isPositive() && (!columnLayout.logicalWidth.hasPercent() || cellLogicalWidth.value() > columnLayout.logicalWidth.value()))
+                        if (cellLogicalWidth.isPositive() && (!columnLayout.logicalWidth.isPercentOrCalc() || cellLogicalWidth.value() > columnLayout.logicalWidth.value()))
                             columnLayout.logicalWidth = cellLogicalWidth;
                         break;
                     default:
                         break;
                     }
                 } else if (!effCol || section->primaryCellAt(i, effCol - 1) != cell) {
                     // If a cell originates in this spanning column ensure we have a min/max width of at least 1px for it.
                     columnLayout.minLogicalWidth = std::max<int>(columnLayout.minLogicalWidth, cell->maxPreferredLogicalWidth() ? 1 : 0);
 
                     // This spanning cell originates in this column. Insert the cell into spanning cells list.
@@ skipping 28 matching lines @@
     unsigned currentColumn = 0;
     for (LayoutTableCol* column = m_table->firstColumn(); column; column = column->nextColumn()) {
         if (column->isTableColumnGroupWithColumnChildren()) {
             groupLogicalWidth = column->style()->logicalWidth();
         } else {
             Length colLogicalWidth = column->style()->logicalWidth();
             // FIXME: calc() on tables should be handled consistently with other lengths. See bug: https://crbug.com/382725
             if (colLogicalWidth.isCalculated() || colLogicalWidth.isAuto())
                 colLogicalWidth = groupLogicalWidth;
             // TODO(alancutter): Make this work correctly for calc lengths.
-            if ((colLogicalWidth.isFixed() || colLogicalWidth.hasPercent()) && colLogicalWidth.isZero())
+            if ((colLogicalWidth.isFixed() || colLogicalWidth.isPercentOrCalc()) && colLogicalWidth.isZero())
                 colLogicalWidth = Length();
             unsigned effCol = m_table->absoluteColumnToEffectiveColumn(currentColumn);
             unsigned span = column->span();
             if (!colLogicalWidth.isAuto() && span == 1 && effCol < nEffCols && m_table->spanOfEffectiveColumn(effCol) == 1) {
                 m_layoutStruct[effCol].logicalWidth = colLogicalWidth;
                 if (colLogicalWidth.isFixed() && m_layoutStruct[effCol].maxLogicalWidth < colLogicalWidth.value())
                     m_layoutStruct[effCol].maxLogicalWidth = colLogicalWidth.value();
             }
             currentColumn += span;
         }
@@ skipping 25 matching lines @@
 static bool shouldScaleColumnsForSelf(LayoutTable* table)
 {
     // Normally, scale all columns to satisfy this from CSS2.2:
     // "A percentage value for a column width is relative to the table width.
     // If the table has 'width: auto', a percentage represents a constraint on the column's width"
 
     // A special case.  If this table is not fixed width and contained inside
     // a cell, then don't bloat the maxwidth by examining percentage growth.
     while (true) {
         Length tw = table->style()->width();
-        if ((!tw.isAuto() && !tw.hasPercent()) || table->isOutOfFlowPositioned())
+        if ((!tw.isAuto() && !tw.isPercentOrCalc()) || table->isOutOfFlowPositioned())
             return true;
         LayoutBlock* cb = table->containingBlock();
 
         while (!cb->isLayoutView() && !cb->isTableCell()
             && cb->style()->width().isAuto() && !cb->isOutOfFlowPositioned())
             cb = cb->containingBlock();
 
         // TODO(dgrogan): Should the second clause check for isFixed() instead?
         if (!cb->isTableCell()
-            || (!cb->style()->width().isAuto() && !cb->style()->width().hasPercent()))
+            || (!cb->style()->width().isAuto() && !cb->style()->width().isPercentOrCalc()))
             return true;
 
         LayoutTableCell* cell = toLayoutTableCell(cb);
         table = cell->table();
         if (cell->colSpan() > 1 || table->isLogicalWidthAuto())
             return false;
     }
     NOTREACHED();
     return true;
 }
@@ skipping 13 matching lines @@
 
     // We substitute 0 percent by (epsilon / percentScaleFactor) percent in two places below to avoid division by zero.
     // FIXME: Handle the 0% cases properly.
     const float epsilon = 1 / 128.0f;
 
     float remainingPercent = 100;
     for (size_t i = 0; i < m_layoutStruct.size(); ++i) {
         minWidth += m_layoutStruct[i].effectiveMinLogicalWidth;
         maxWidth += m_layoutStruct[i].effectiveMaxLogicalWidth;
         if (scaleColumnsForSelf) {
-            if (m_layoutStruct[i].effectiveLogicalWidth.hasPercent()) {
+            if (m_layoutStruct[i].effectiveLogicalWidth.isPercentOrCalc()) {
                 float percent = std::min(static_cast<float>(m_layoutStruct[i].effectiveLogicalWidth.percent()), remainingPercent);
                 float logicalWidth = static_cast<float>(m_layoutStruct[i].effectiveMaxLogicalWidth) * 100 / std::max(percent, epsilon);
                 maxPercent = std::max(logicalWidth,  maxPercent);
                 remainingPercent -= percent;
             } else {
                 maxNonPercent += m_layoutStruct[i].effectiveMaxLogicalWidth;
             }
         }
     }
 
@@ skipping 91 matching lines @@
                 // fall through
             default:
                 // If the column is a percentage width, do not let the spanning cell overwrite the
                 // width value.  This caused a mis-layout on amazon.com.
                 // Sample snippet:
                 // <table border=2 width=100%><
                 //   <tr><td>1</td><td colspan=2>2-3</tr>
                 //   <tr><td>1</td><td colspan=2 width=100%>2-3</td></tr>
                 // </table>
                 // TODO(alancutter): Make this work correctly for calc lengths.
-                if (!columnLayout.effectiveLogicalWidth.hasPercent()) {
+                if (!columnLayout.effectiveLogicalWidth.isPercentOrCalc()) {
                     columnLayout.effectiveLogicalWidth = Length();
                     allColsArePercent = false;
                 } else {
                     totalPercent += columnLayout.effectiveLogicalWidth.percent();
                 }
                 allColsAreFixed = false;
             }
             if (!columnLayout.emptyCellsOnly)
                 spanHasEmptyCellsOnly = false;
             span -= m_table->spanOfEffectiveColumn(lastCol);
             spanMinLogicalWidth += columnLayout.effectiveMinLogicalWidth;
             spanMaxLogicalWidth += columnLayout.effectiveMaxLogicalWidth;
             lastCol++;
             cellMinLogicalWidth -= spacingInRowDirection;
             cellMaxLogicalWidth -= spacingInRowDirection;
         }
 
         // adjust table max width if needed
-        if (cellLogicalWidth.hasPercent()) {
+        if (cellLogicalWidth.isPercentOrCalc()) {
             if (totalPercent > cellLogicalWidth.percent() || allColsArePercent) {
                 // can't satify this condition, treat as variable
                 cellLogicalWidth = Length();
             } else {
                 maxLogicalWidth = std::max(maxLogicalWidth, static_cast<int>(std::max(spanMaxLogicalWidth, cellMaxLogicalWidth) * 100  / cellLogicalWidth.percent()));
 
                 // all non percent columns in the span get percent values to sum up correctly.
                 float percentMissing = cellLogicalWidth.percent() - totalPercent;
                 int totalWidth = 0;
                 for (unsigned pos = effCol; pos < lastCol; ++pos) {
-                    if (!m_layoutStruct[pos].effectiveLogicalWidth.hasPercent())
+                    if (!m_layoutStruct[pos].effectiveLogicalWidth.isPercentOrCalc())
                         totalWidth += m_layoutStruct[pos].clampedEffectiveMaxLogicalWidth();
                 }
 
                 for (unsigned pos = effCol; pos < lastCol && totalWidth > 0; ++pos) {
-                    if (!m_layoutStruct[pos].effectiveLogicalWidth.hasPercent()) {
+                    if (!m_layoutStruct[pos].effectiveLogicalWidth.isPercentOrCalc()) {
                         float percent = percentMissing * static_cast<float>(m_layoutStruct[pos].effectiveMaxLogicalWidth) / totalWidth;
                         totalWidth -= m_layoutStruct[pos].clampedEffectiveMaxLogicalWidth();
                         percentMissing -= percent;
                         if (percent > 0)
                             m_layoutStruct[pos].effectiveLogicalWidth.setValue(Percent, percent);
                         else
                             m_layoutStruct[pos].effectiveLogicalWidth = Length();
                     }
                 }
             }
         }
 
         // make sure minWidth and maxWidth of the spanning cell are honoured
         if (cellMinLogicalWidth > spanMinLogicalWidth) {
             if (allColsAreFixed) {
                 for (unsigned pos = effCol; fixedWidth > 0 && pos < lastCol; ++pos) {
                     int cellLogicalWidth = std::max(m_layoutStruct[pos].effectiveMinLogicalWidth, static_cast<int>(cellMinLogicalWidth * m_layoutStruct[pos].logicalWidth.value() / fixedWidth));
                     fixedWidth -= m_layoutStruct[pos].logicalWidth.value();
                     cellMinLogicalWidth -= cellLogicalWidth;
                     m_layoutStruct[pos].effectiveMinLogicalWidth = cellLogicalWidth;
                 }
             } else if (allColsArePercent) {
                 // In this case, we just split the colspan's min amd max widths following the percentage.
                 int allocatedMinLogicalWidth = 0;
                 int allocatedMaxLogicalWidth = 0;
                 for (unsigned pos = effCol; pos < lastCol; ++pos) {
                     // TODO(alancutter): Make this work correctly for calc lengths.
-                    ASSERT(m_layoutStruct[pos].logicalWidth.hasPercent() || m_layoutStruct[pos].effectiveLogicalWidth.hasPercent());
+                    DCHECK(m_layoutStruct[pos].logicalWidth.isPercentOrCalc() || m_layoutStruct[pos].effectiveLogicalWidth.isPercentOrCalc());
                     // |allColsArePercent| means that either the logicalWidth *or* the effectiveLogicalWidth are percents, handle both of them here.
-                    float percent = m_layoutStruct[pos].logicalWidth.hasPercent() ? m_layoutStruct[pos].logicalWidth.percent() : m_layoutStruct[pos].effectiveLogicalWidth.percent();
+                    float percent = m_layoutStruct[pos].logicalWidth.isPercentOrCalc() ? m_layoutStruct[pos].logicalWidth.percent() : m_layoutStruct[pos].effectiveLogicalWidth.percent();
                     int columnMinLogicalWidth = static_cast<int>(percent * cellMinLogicalWidth / totalPercent);
                     int columnMaxLogicalWidth = static_cast<int>(percent * cellMaxLogicalWidth / totalPercent);
                     m_layoutStruct[pos].effectiveMinLogicalWidth = std::max(m_layoutStruct[pos].effectiveMinLogicalWidth, columnMinLogicalWidth);
                     m_layoutStruct[pos].effectiveMaxLogicalWidth = columnMaxLogicalWidth;
                     allocatedMinLogicalWidth += columnMinLogicalWidth;
                     allocatedMaxLogicalWidth += columnMaxLogicalWidth;
                 }
                 ASSERT(allocatedMinLogicalWidth <= cellMinLogicalWidth);
                 ASSERT(allocatedMaxLogicalWidth <= cellMaxLogicalWidth);
                 cellMinLogicalWidth -= allocatedMinLogicalWidth;
@@ skipping 19 matching lines @@
                         int colMinLogicalWidth = std::max<int>(m_layoutStruct[pos].effectiveMinLogicalWidth, static_cast<int>(remainingMaxLogicalWidth ? cellMinLogicalWidth * static_cast<float>(m_layoutStruct[pos].effectiveMaxLogicalWidth) / remainingMaxLogicalWidth : cellMinLogicalWidth));
                         colMinLogicalWidth = std::min<int>(m_layoutStruct[pos].effectiveMinLogicalWidth + (cellMinLogicalWidth - remainingMinLogicalWidth), colMinLogicalWidth);
                         remainingMaxLogicalWidth -= m_layoutStruct[pos].effectiveMaxLogicalWidth;
                         remainingMinLogicalWidth -= m_layoutStruct[pos].effectiveMinLogicalWidth;
                         cellMinLogicalWidth -= colMinLogicalWidth;
                         m_layoutStruct[pos].effectiveMinLogicalWidth = colMinLogicalWidth;
                     }
                 }
             }
         }
-        if (!cellLogicalWidth.hasPercent()) {
+        if (!cellLogicalWidth.isPercentOrCalc()) {
             if (cellMaxLogicalWidth > spanMaxLogicalWidth) {
                 for (unsigned pos = effCol; spanMaxLogicalWidth >= 0 && pos < lastCol; ++pos) {
                     int colMaxLogicalWidth = std::max(m_layoutStruct[pos].effectiveMaxLogicalWidth, static_cast<int>(spanMaxLogicalWidth ? cellMaxLogicalWidth * static_cast<float>(m_layoutStruct[pos].effectiveMaxLogicalWidth) / spanMaxLogicalWidth : cellMaxLogicalWidth));
                     spanMaxLogicalWidth -= m_layoutStruct[pos].effectiveMaxLogicalWidth;
                     cellMaxLogicalWidth -= colMaxLogicalWidth;
                     m_layoutStruct[pos].effectiveMaxLogicalWidth = colMaxLogicalWidth;
                 }
             }
         } else {
             for (unsigned pos = effCol; pos < lastCol; ++pos)
@@ skipping 93 matching lines @@
             break;
         default:
             break;
         }
     }
 
     // allocate width to percent cols
     if (available > 0 && havePercent) {
         for (size_t i = 0; i < nEffCols; ++i) {
             Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
-            if (logicalWidth.hasPercent()) {
+            if (logicalWidth.isPercentOrCalc()) {
                 int cellLogicalWidth = std::max<int>(m_layoutStruct[i].effectiveMinLogicalWidth,
                     minimumValueForLength(logicalWidth, LayoutUnit(tableLogicalWidth)).toInt());
                 available += m_layoutStruct[i].computedLogicalWidth - cellLogicalWidth;
                 m_layoutStruct[i].computedLogicalWidth = cellLogicalWidth;
             }
         }
         if (totalPercent > 100) {
             // remove overallocated space from the last columns
             int excess = tableLogicalWidth * (totalPercent - 100) / 100;
             for (unsigned i = nEffCols; i; ) {
                 --i;
-                if (m_layoutStruct[i].effectiveLogicalWidth.hasPercent()) {
+                if (m_layoutStruct[i].effectiveLogicalWidth.isPercentOrCalc()) {
                     int cellLogicalWidth = m_layoutStruct[i].computedLogicalWidth;
                     int reduction = std::min(cellLogicalWidth,  excess);
                     // the lines below might look inconsistent, but that's the way it's handled in mozilla
                     excess -= reduction;
                     int newLogicalWidth = std::max<int>(m_layoutStruct[i].effectiveMinLogicalWidth, cellLogicalWidth - reduction);
                     available += cellLogicalWidth - newLogicalWidth;
                     m_layoutStruct[i].computedLogicalWidth = newLogicalWidth;
                 }
             }
         }
@@ skipping 111 matching lines @@
             int reduce = available * minMaxDiff / logicalWidthBeyondMin;
             m_layoutStruct[i].computedLogicalWidth += reduce;
             available -= reduce;
             logicalWidthBeyondMin -= minMaxDiff;
             if (available >= 0)
                 break;
         }
     }
 }
 } // namespace blink