Fix behaviour of empty cells in tables with colspans

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 49 matching lines @@
             for (unsigned i = 0; i < numRows; i++) {
                 LayoutTableSection::CellStruct current = section->cellAt(i, effCol);
                 LayoutTableCell* cell = current.primaryCell();
 
                 if (current.inColSpan || !cell)
                     continue;
                 columnLayout.columnHasNoCells = false;
 
                 if (cell->maxPreferredLogicalWidth())
                     columnLayout.emptyCellsOnly = false;
+                if (cell->colSpan() == 1) {
 
-                if (cell->colSpan() == 1) {
                     columnLayout.minLogicalWidth = std::max<int>(cell->minPreferredLogicalWidth(), columnLayout.minLogicalWidth);
                     if (cell->maxPreferredLogicalWidth() > columnLayout.maxLogicalWidth) {
                         columnLayout.maxLogicalWidth = cell->maxPreferredLogicalWidth();
                         maxContributor = cell;
                     }
 
                     // All browsers implement a size limit on the cell's max width.
                     // Our limit is based on KHTML's representation that used 16 bits widths.
                     // FIXME: Other browsers have a lower limit for the cell's max width.
                     const int cCellMaxWidth = 32760;
@@ skipping 26 matching lines @@
                     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()))
                             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.
                     insertSpanCell(cell);
                 }
             }
         }
     }
 
     // Nav/IE weirdness
     if (columnLayout.logicalWidth.isFixed()) {
         if (m_table->document().inQuirksMode() && columnLayout.maxLogicalWidth > columnLayout.logicalWidth.value() && fixedContributor != maxContributor) {
@@ skipping 174 matching lines @@
         int cellMinLogicalWidth = cell->minPreferredLogicalWidth() + spacingInRowDirection;
         int cellMaxLogicalWidth = cell->maxPreferredLogicalWidth() + spacingInRowDirection;
         float totalPercent = 0;
         int spanMinLogicalWidth = 0;
         int spanMaxLogicalWidth = 0;
         bool allColsArePercent = true;
         bool allColsAreFixed = true;
         bool haveAuto = false;
         bool spanHasEmptyCellsOnly = true;
         int fixedWidth = 0;
+        int numAuto = 0;
         while (lastCol < nEffCols && span > 0) {
             Layout& columnLayout = m_layoutStruct[lastCol];
             switch (columnLayout.logicalWidth.type()) {
             case Percent:
                 totalPercent += columnLayout.logicalWidth.percent();
                 allColsAreFixed = false;
                 break;
             case Fixed:
                 if (columnLayout.logicalWidth.value() > 0) {
                     fixedWidth += columnLayout.logicalWidth.value();
                     allColsArePercent = false;
                     // IE resets effWidth to Auto here, but this breaks the konqueror about page and seems to be some bad
                     // legacy behaviour anyway. mozilla doesn't do this so I decided we don't neither.
                     break;
                 }
                 // fall through
             case Auto:
                 haveAuto = true;
+                if (!columnLayout.columnHasNoCells)
+                    numAuto++;
                 // 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.
@@ skipping 20 matching lines @@
             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.hasPercent() && (!m_layoutStruct[pos].emptyCellsOnly || spanHasEmptyCellsOnly))
                         totalWidth += m_layoutStruct[pos].clampedEffectiveMaxLogicalWidth();
                 }
 
                 for (unsigned pos = effCol; pos < lastCol && totalWidth > 0; ++pos) {
-                    if (!m_layoutStruct[pos].effectiveLogicalWidth.hasPercent()) {
-                        float percent = percentMissing * static_cast<float>(m_layoutStruct[pos].effectiveMaxLogicalWidth) / totalWidth;
+                    // Empty columns shouldn't get any share of a span's percent width.
+                    if (!m_layoutStruct[pos].effectiveLogicalWidth.hasPercent() && (!m_layoutStruct[pos].emptyCellsOnly || spanHasEmptyCellsOnly)) {
+                        float percent = percentMissing * static_cast<float>(m_layoutStruct[pos].clampedEffectiveMaxLogicalWidth()) / totalWidth;
                         totalWidth -= m_layoutStruct[pos].clampedEffectiveMaxLogicalWidth();
                         percentMissing -= percent;
-                        if (percent > 0)
+                        if (percent > 0 && !m_layoutStruct[pos].columnHasNoCells)
                             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) {
@@ skipping 47 matching lines @@
                         remainingMaxLogicalWidth -= m_layoutStruct[pos].effectiveMaxLogicalWidth;
                         remainingMinLogicalWidth -= m_layoutStruct[pos].effectiveMinLogicalWidth;
                         cellMinLogicalWidth -= colMinLogicalWidth;
                         m_layoutStruct[pos].effectiveMinLogicalWidth = colMinLogicalWidth;
                     }
                 }
             }
         }
         if (!cellLogicalWidth.hasPercent()) {
             if (cellMaxLogicalWidth > spanMaxLogicalWidth) {
+                int widthAvailableToAuto = cellMaxLogicalWidth - fixedWidth;
                 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;
+                    if (m_layoutStruct[pos].logicalWidth.isAuto() && m_layoutStruct[pos].emptyCellsOnly && !m_layoutStruct[pos].columnHasNoCells && !spanHasEmptyCellsOnly)
+                        m_layoutStruct[pos].effectiveMinLogicalWidth = widthAvailableToAuto / numAuto;
                 }
             }
         } else {
             for (unsigned pos = effCol; pos < lastCol; ++pos)
                 m_layoutStruct[pos].maxLogicalWidth = std::max(m_layoutStruct[pos].maxLogicalWidth, m_layoutStruct[pos].minLogicalWidth);
         }
         // treat span ranges consisting of empty cells only as if they had content
         if (spanHasEmptyCellsOnly) {
             for (unsigned pos = effCol; pos < lastCol; ++pos)
                 m_layoutStruct[pos].emptyCellsOnly = false;
@@ skipping 69 matching lines @@
             havePercent = true;
             totalPercent += logicalWidth.percent();
             break;
         case Fixed:
             numFixed++;
             totalFixed += m_layoutStruct[i].clampedEffectiveMaxLogicalWidth();
             // fall through
             break;
         case Auto:
             if (m_layoutStruct[i].emptyCellsOnly) {
-                numAutoEmptyCellsOnly++;
+                if (!m_layoutStruct[i].columnHasNoCells)
+                    numAutoEmptyCellsOnly++;
             } else {
                 numAuto++;
                 totalAuto += m_layoutStruct[i].clampedEffectiveMaxLogicalWidth();
             }
             if (!m_layoutStruct[i].columnHasNoCells)
                 allocAuto += cellLogicalWidth;
             break;
         default:
             break;
         }
@@ skipping 137 matching lines @@
             int reduce = available * minMaxDiff / logicalWidthBeyondMin;
             m_layoutStruct[i].computedLogicalWidth += reduce;
             available -= reduce;
             logicalWidthBeyondMin -= minMaxDiff;
             if (available >= 0)
                 break;
         }
     }
 }
 }