Changeset 99254 in webkit

Timestamp:

Nov 3, 2011 5:56:59 PM (12 years ago)

Author:

leviw@chromium.org

Message:

Correct usage of LayoutUnits and integers in Table rendering classes
​https://bugs.webkit.org/show_bug.cgi?id=71500

Reviewed by Darin Adler.

Fixing the Table layout classes to operate on integers -- sub-pixel table layout breaks
the spec. Meanwhile correcting the Table rendering classes themselves to still use
LayoutUnits.

No new tests -- no change in behavior.

• rendering/AutoTableLayout.cpp: Reverting to operating on integers.

(WebCore::AutoTableLayout::recalcColumn):
(WebCore::AutoTableLayout::computePreferredLogicalWidths):
(WebCore::AutoTableLayout::calcEffectiveLogicalWidth):
(WebCore::AutoTableLayout::layout):

• rendering/AutoTableLayout.h: Reverting to operating on integers.
• rendering/FixedTableLayout.cpp: Ditto.

(WebCore::FixedTableLayout::computePreferredLogicalWidths):
(WebCore::FixedTableLayout::layout):

• rendering/RenderTable.h: Switching to LayoutUnits.

(WebCore::RenderTable::getColumnPos):
(WebCore::RenderTable::bordersPaddingAndSpacingInRowDirection):

• rendering/RenderTableCell.cpp: Switching to LayoutUnits.

(WebCore::RenderTableCell::updateLogicalWidth):
(WebCore::RenderTableCell::setOverrideHeightFromRowHeight):
(WebCore::RenderTableCell::computeRectForRepaint):
(WebCore::RenderTableCell::cellBaselinePosition):
(WebCore::RenderTableCell::scrollbarsChanged):

• rendering/RenderTableCell.h: Switching to LayoutUnits
• rendering/RenderTableSection.cpp: Ditto.

(WebCore::RenderTableSection::setCellLogicalWidths):
(WebCore::RenderTableSection::layoutRows):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• rendering/AutoTableLayout.cpp (modified) (29 diffs)
• rendering/AutoTableLayout.h (modified) (1 diff)
• rendering/FixedTableLayout.cpp (modified) (6 diffs)
• rendering/RenderTable.h (modified) (2 diffs)
• rendering/RenderTableCell.cpp (modified) (5 diffs)
• rendering/RenderTableCell.h (modified) (4 diffs)
• rendering/RenderTableSection.cpp (modified) (3 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-11-03  Levi Weintraub  <leviw@chromium.org>
+
+        Correct usage of LayoutUnits and integers in Table rendering classes
+        https://bugs.webkit.org/show_bug.cgi?id=71500
+
+        Reviewed by Darin Adler.
+
+        Fixing the Table layout classes to operate on integers -- sub-pixel table layout breaks
+        the spec. Meanwhile correcting the Table rendering classes themselves to still use
+        LayoutUnits.
+
+        No new tests -- no change in behavior.
+
+        * rendering/AutoTableLayout.cpp: Reverting to operating on integers.
+        (WebCore::AutoTableLayout::recalcColumn):
+        (WebCore::AutoTableLayout::computePreferredLogicalWidths):
+        (WebCore::AutoTableLayout::calcEffectiveLogicalWidth):
+        (WebCore::AutoTableLayout::layout):
+        * rendering/AutoTableLayout.h: Reverting to operating on integers.
+        * rendering/FixedTableLayout.cpp: Ditto.
+        (WebCore::FixedTableLayout::computePreferredLogicalWidths):
+        (WebCore::FixedTableLayout::layout):
+        * rendering/RenderTable.h: Switching to LayoutUnits.
+        (WebCore::RenderTable::getColumnPos):
+        (WebCore::RenderTable::bordersPaddingAndSpacingInRowDirection):
+        * rendering/RenderTableCell.cpp: Switching to LayoutUnits.
+        (WebCore::RenderTableCell::updateLogicalWidth):
+        (WebCore::RenderTableCell::setOverrideHeightFromRowHeight):
+        (WebCore::RenderTableCell::computeRectForRepaint):
+        (WebCore::RenderTableCell::cellBaselinePosition):
+        (WebCore::RenderTableCell::scrollbarsChanged):
+        * rendering/RenderTableCell.h: Switching to LayoutUnits
+        * rendering/RenderTableSection.cpp: Ditto.
+        (WebCore::RenderTableSection::setCellLogicalWidths):
+        (WebCore::RenderTableSection::layoutRows):
+
 2011-11-03  James Robinson  <jamesr@chromium.org>
 

trunk/Source/WebCore/rendering/AutoTableLayout.cpp

@@ -70 +70 @@
                     // A cell originates in this column.  Ensure we have
                     // a min/max width of at least 1px for this column now.
-                    columnLayout.minLogicalWidth = max<LayoutUnit>(columnLayout.minLogicalWidth, cellHasContent ? 1 : 0);
-                    columnLayout.maxLogicalWidth = max<LayoutUnit>(columnLayout.maxLogicalWidth, 1);
+                    columnLayout.minLogicalWidth = max<int>(columnLayout.minLogicalWidth, cellHasContent ? 1 : 0);
+                    columnLayout.maxLogicalWidth = max<int>(columnLayout.maxLogicalWidth, 1);
                     if (cell->preferredLogicalWidthsDirty())
                         cell->computePreferredLogicalWidths();
-                    columnLayout.minLogicalWidth = max(cell->minPreferredLogicalWidth(), columnLayout.minLogicalWidth);
+                    columnLayout.minLogicalWidth = max<int>(cell->minPreferredLogicalWidth(), columnLayout.minLogicalWidth);
                     if (cell->maxPreferredLogicalWidth() > columnLayout.maxLogicalWidth) {
                         columnLayout.maxLogicalWidth = cell->maxPreferredLogicalWidth();
@@ -120 +120 @@
                     // This spanning cell originates in this column.  Ensure we have
                     // a min/max width of at least 1px for this column now.
-                    columnLayout.minLogicalWidth = max<LayoutUnit>(columnLayout.minLogicalWidth, cellHasContent ? 1 : 0);
-                    columnLayout.maxLogicalWidth = max<LayoutUnit>(columnLayout.maxLogicalWidth, 1);
+                    columnLayout.minLogicalWidth = max<int>(columnLayout.minLogicalWidth, cellHasContent ? 1 : 0);
+                    columnLayout.maxLogicalWidth = max<int>(columnLayout.maxLogicalWidth, 1);
                     insertSpanCell(cell);
                 }
@@ -224 +224 @@
     fullRecalc();
 
-    LayoutUnit spanMaxLogicalWidth = calcEffectiveLogicalWidth();
+    int spanMaxLogicalWidth = calcEffectiveLogicalWidth();
     minWidth = 0;
     maxWidth = 0;
@@ -252 +252 @@
     if (scaleColumns) {
         maxNonPercent = maxNonPercent * 100 / max(remainingPercent, epsilon);
-        // FIXME: Remove unnecessary rounding when layout is off ints: webkit.org/b/63656
-        maxWidth = max<LayoutUnit>(maxWidth, static_cast<LayoutUnit>(min(maxNonPercent, numeric_limits<LayoutUnit>::max() / 2.0f)));
-        maxWidth = max<LayoutUnit>(maxWidth, static_cast<LayoutUnit>(min(maxPercent, numeric_limits<LayoutUnit>::max() / 2.0f)));
-    }
-
-    maxWidth = max(maxWidth, spanMaxLogicalWidth);
-
-    LayoutUnit bordersPaddingAndSpacing = m_table->bordersPaddingAndSpacingInRowDirection();
+        maxWidth = max(maxWidth, static_cast<int>(min(maxNonPercent, numeric_limits<LayoutUnit>::max() / 2.0f)));
+        maxWidth = max(maxWidth, static_cast<int>(min(maxPercent, numeric_limits<LayoutUnit>::max() / 2.0f)));
+    }
+
+    maxWidth = max<int>(maxWidth, spanMaxLogicalWidth);
+
+    int bordersPaddingAndSpacing = m_table->bordersPaddingAndSpacingInRowDirection();
     minWidth += bordersPaddingAndSpacing;
     maxWidth += bordersPaddingAndSpacing;
@@ -265 +264 @@
     Length tableLogicalWidth = m_table->style()->logicalWidth();
     if (tableLogicalWidth.isFixed() && tableLogicalWidth.value() > 0) {
-        minWidth = max<LayoutUnit>(minWidth, tableLogicalWidth.value());
+        minWidth = max<int>(minWidth, tableLogicalWidth.value());
         maxWidth = minWidth;
     } else if (!remainingPercent && maxNonPercent) {
@@ -306 +305 @@
         float cellMaxLogicalWidth = cell->maxPreferredLogicalWidth() + spacingInRowDirection;
         float totalPercent = 0;
-        LayoutUnit spanMinLogicalWidth = 0;
+        int spanMinLogicalWidth = 0;
         float spanMaxLogicalWidth = 0;
         bool allColsArePercent = true;
@@ -312 +311 @@
         bool haveAuto = false;
         bool spanHasEmptyCellsOnly = true;
-        LayoutUnit fixedWidth = 0;
+        int fixedWidth = 0;
         while (lastCol < nEffCols && span > 0) {
             Layout& columnLayout = m_layoutStruct[lastCol];
@@ -391 +390 @@
             if (allColsAreFixed) {
                 for (unsigned pos = effCol; fixedWidth > 0 && pos < lastCol; ++pos) {
-                    LayoutUnit cellLogicalWidth = max(m_layoutStruct[pos].effectiveMinLogicalWidth, cellMinLogicalWidth * m_layoutStruct[pos].logicalWidth.value() / fixedWidth);
+                    int cellLogicalWidth = max(m_layoutStruct[pos].effectiveMinLogicalWidth, static_cast<int>(cellMinLogicalWidth * m_layoutStruct[pos].logicalWidth.value() / fixedWidth));
                     fixedWidth -= m_layoutStruct[pos].logicalWidth.value();
                     cellMinLogicalWidth -= cellLogicalWidth;
@@ -398 +397 @@
             } else {
                 float remainingMaxLogicalWidth = spanMaxLogicalWidth;
-                LayoutUnit remainingMinLogicalWidth = spanMinLogicalWidth;
+                int remainingMinLogicalWidth = spanMinLogicalWidth;
                 
                 // Give min to variable first, to fixed second, and to others third.
                 for (unsigned pos = effCol; remainingMaxLogicalWidth >= 0 && pos < lastCol; ++pos) {
                     if (m_layoutStruct[pos].logicalWidth.isFixed() && haveAuto && fixedWidth <= cellMinLogicalWidth) {
-                        int colMinLogicalWidth = max<LayoutUnit>(m_layoutStruct[pos].effectiveMinLogicalWidth, m_layoutStruct[pos].logicalWidth.value());
+                        int colMinLogicalWidth = max<int>(m_layoutStruct[pos].effectiveMinLogicalWidth, m_layoutStruct[pos].logicalWidth.value());
                         fixedWidth -= m_layoutStruct[pos].logicalWidth.value();
                         remainingMinLogicalWidth -= m_layoutStruct[pos].effectiveMinLogicalWidth;
@@ -414 +413 @@
                 for (unsigned pos = effCol; remainingMaxLogicalWidth >= 0 && pos < lastCol && remainingMinLogicalWidth < cellMinLogicalWidth; ++pos) {
                     if (!(m_layoutStruct[pos].logicalWidth.isFixed() && haveAuto && fixedWidth <= cellMinLogicalWidth)) {
-                        int colMinLogicalWidth = max<LayoutUnit>(m_layoutStruct[pos].effectiveMinLogicalWidth, static_cast<int>(remainingMaxLogicalWidth ? cellMinLogicalWidth * static_cast<float>(m_layoutStruct[pos].effectiveMaxLogicalWidth) / remainingMaxLogicalWidth : cellMinLogicalWidth));
-                        colMinLogicalWidth = min<LayoutUnit>(m_layoutStruct[pos].effectiveMinLogicalWidth + (cellMinLogicalWidth - remainingMinLogicalWidth), colMinLogicalWidth);
+                        int colMinLogicalWidth = max<int>(m_layoutStruct[pos].effectiveMinLogicalWidth, static_cast<int>(remainingMaxLogicalWidth ? cellMinLogicalWidth * static_cast<float>(m_layoutStruct[pos].effectiveMaxLogicalWidth) / remainingMaxLogicalWidth : cellMinLogicalWidth));
+                        colMinLogicalWidth = min<int>(m_layoutStruct[pos].effectiveMinLogicalWidth + (cellMinLogicalWidth - remainingMinLogicalWidth), colMinLogicalWidth);
                         remainingMaxLogicalWidth -= m_layoutStruct[pos].effectiveMaxLogicalWidth;
                         remainingMinLogicalWidth -= m_layoutStruct[pos].effectiveMinLogicalWidth;
@@ -427 +426 @@
             if (cellMaxLogicalWidth > spanMaxLogicalWidth) {
                 for (unsigned pos = effCol; spanMaxLogicalWidth >= 0 && pos < lastCol; ++pos) {
-                    int colMaxLogicalWidth = max<LayoutUnit>(m_layoutStruct[pos].effectiveMaxLogicalWidth, static_cast<int>(spanMaxLogicalWidth ? cellMaxLogicalWidth * static_cast<float>(m_layoutStruct[pos].effectiveMaxLogicalWidth) / spanMaxLogicalWidth : cellMaxLogicalWidth));
+                    int colMaxLogicalWidth = 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;
@@ -478 +477 @@
 {
     // table layout based on the values collected in the layout structure.
-    LayoutUnit tableLogicalWidth = m_table->logicalWidth() - m_table->bordersPaddingAndSpacingInRowDirection();
-    LayoutUnit available = tableLogicalWidth;
+    int tableLogicalWidth = m_table->logicalWidth() - m_table->bordersPaddingAndSpacingInRowDirection();
+    int available = tableLogicalWidth;
     size_t nEffCols = m_table->numEffCols();
 
@@ -502 +501 @@
     // fill up every cell with its minWidth
     for (size_t i = 0; i < nEffCols; ++i) {
-        LayoutUnit cellLogicalWidth = m_layoutStruct[i].effectiveMinLogicalWidth;
+        int cellLogicalWidth = m_layoutStruct[i].effectiveMinLogicalWidth;
         m_layoutStruct[i].computedLogicalWidth = cellLogicalWidth;
         available -= cellLogicalWidth;
@@ -538 +537 @@
             Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
             if (logicalWidth.isPercent()) {
-                LayoutUnit cellLogicalWidth = max<LayoutUnit>(m_layoutStruct[i].effectiveMinLogicalWidth, logicalWidth.calcMinValue(tableLogicalWidth));
+                int cellLogicalWidth = max<int>(m_layoutStruct[i].effectiveMinLogicalWidth, logicalWidth.calcMinValue(tableLogicalWidth));
                 available += m_layoutStruct[i].computedLogicalWidth - cellLogicalWidth;
                 m_layoutStruct[i].computedLogicalWidth = cellLogicalWidth;
@@ -545 +544 @@
         if (totalPercent > 100) {
             // remove overallocated space from the last columns
-            LayoutUnit excess = tableLogicalWidth * (totalPercent - 100) / 100;
+            int excess = tableLogicalWidth * (totalPercent - 100) / 100;
             for (int i = nEffCols - 1; i >= 0; --i) {
                 if (m_layoutStruct[i].effectiveLogicalWidth.isPercent()) {
-                    LayoutUnit cellLogicalWidth = m_layoutStruct[i].computedLogicalWidth;
-                    LayoutUnit reduction = min(cellLogicalWidth,  excess);
+                    int cellLogicalWidth = m_layoutStruct[i].computedLogicalWidth;
+                    int reduction = min(cellLogicalWidth,  excess);
                     // the lines below might look inconsistent, but that's the way it's handled in mozilla
                     excess -= reduction;
-                    LayoutUnit newLogicalWidth = max<LayoutUnit>(m_layoutStruct[i].effectiveMinLogicalWidth, cellLogicalWidth - reduction);
+                    int newLogicalWidth = max<int>(m_layoutStruct[i].effectiveMinLogicalWidth, cellLogicalWidth - reduction);
                     available += cellLogicalWidth - newLogicalWidth;
                     m_layoutStruct[i].computedLogicalWidth = newLogicalWidth;
@@ -577 +576 @@
             if (logicalWidth.isRelative() && logicalWidth.value() != 0) {
                 // width=0* gets effMinWidth.
-                LayoutUnit cellLogicalWidth = logicalWidth.value() * tableLogicalWidth / totalRelative;
+                int cellLogicalWidth = logicalWidth.value() * tableLogicalWidth / totalRelative;
                 available += m_layoutStruct[i].computedLogicalWidth - cellLogicalWidth;
                 m_layoutStruct[i].computedLogicalWidth = cellLogicalWidth;
@@ -590 +589 @@
             Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
             if (logicalWidth.isAuto() && totalAuto && !m_layoutStruct[i].emptyCellsOnly) {
-                LayoutUnit cellLogicalWidth = max<LayoutUnit>(m_layoutStruct[i].computedLogicalWidth, static_cast<LayoutUnit>(available * static_cast<float>(m_layoutStruct[i].effectiveMaxLogicalWidth) / totalAuto));
+                int cellLogicalWidth = max<int>(m_layoutStruct[i].computedLogicalWidth, static_cast<int>(available * static_cast<float>(m_layoutStruct[i].effectiveMaxLogicalWidth) / totalAuto));
                 available -= cellLogicalWidth;
                 totalAuto -= m_layoutStruct[i].effectiveMaxLogicalWidth;
@@ -603 +602 @@
             Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
             if (logicalWidth.isFixed()) {
-                LayoutUnit cellLogicalWidth = static_cast<LayoutUnit>(available * static_cast<float>(m_layoutStruct[i].effectiveMaxLogicalWidth) / totalFixed);
+                int cellLogicalWidth = static_cast<int>(available * static_cast<float>(m_layoutStruct[i].effectiveMaxLogicalWidth) / totalFixed);
                 available -= cellLogicalWidth;
                 totalFixed -= m_layoutStruct[i].effectiveMaxLogicalWidth;
@@ -616 +615 @@
             Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
             if (logicalWidth.isPercent()) {
-                LayoutUnit cellLogicalWidth = available * logicalWidth.percent() / totalPercent;
+                int cellLogicalWidth = available * logicalWidth.percent() / totalPercent;
                 available -= cellLogicalWidth;
                 totalPercent -= logicalWidth.percent();
@@ -634 +633 @@
             if (m_layoutStruct[i].effectiveLogicalWidth.isAuto() && m_layoutStruct[i].emptyCellsOnly)
                 continue;
-            LayoutUnit cellLogicalWidth = available / total;
+            int cellLogicalWidth = available / total;
             available -= cellLogicalWidth;
             total--;
@@ -651 +650 @@
         // This is basically the reverse of how we grew the cells.
         if (available < 0) {
-            LayoutUnit logicalWidthBeyondMin = 0;
+            int logicalWidthBeyondMin = 0;
             for (int i = nEffCols - 1; i >= 0; --i) {
                 Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
@@ -661 +660 @@
                 Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
                 if (logicalWidth.isAuto()) {
-                    LayoutUnit minMaxDiff = m_layoutStruct[i].computedLogicalWidth - m_layoutStruct[i].effectiveMinLogicalWidth;
-                    LayoutUnit reduce = available * minMaxDiff / logicalWidthBeyondMin;
+                    int minMaxDiff = m_layoutStruct[i].computedLogicalWidth - m_layoutStruct[i].effectiveMinLogicalWidth;
+                    int reduce = available * minMaxDiff / logicalWidthBeyondMin;
                     m_layoutStruct[i].computedLogicalWidth += reduce;
                     available -= reduce;
@@ -673 +672 @@
 
         if (available < 0) {
-            LayoutUnit logicalWidthBeyondMin = 0;
+            int logicalWidthBeyondMin = 0;
             for (int i = nEffCols - 1; i >= 0; --i) {
                 Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
@@ -683 +682 @@
                 Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
                 if (logicalWidth.isRelative()) {
-                    LayoutUnit minMaxDiff = m_layoutStruct[i].computedLogicalWidth - m_layoutStruct[i].effectiveMinLogicalWidth;
-                    LayoutUnit reduce = available * minMaxDiff / logicalWidthBeyondMin;
+                    int minMaxDiff = m_layoutStruct[i].computedLogicalWidth - m_layoutStruct[i].effectiveMinLogicalWidth;
+                    int reduce = available * minMaxDiff / logicalWidthBeyondMin;
                     m_layoutStruct[i].computedLogicalWidth += reduce;
                     available -= reduce;
@@ -695 +694 @@
 
         if (available < 0) {
-            LayoutUnit logicalWidthBeyondMin = 0;
+            int logicalWidthBeyondMin = 0;
             for (int i = nEffCols - 1; i >= 0; --i) {
                 Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
@@ -705 +704 @@
                 Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
                 if (logicalWidth.isFixed()) {
-                    LayoutUnit minMaxDiff = m_layoutStruct[i].computedLogicalWidth - m_layoutStruct[i].effectiveMinLogicalWidth;
-                    LayoutUnit reduce = available * minMaxDiff / logicalWidthBeyondMin;
+                    int minMaxDiff = m_layoutStruct[i].computedLogicalWidth - m_layoutStruct[i].effectiveMinLogicalWidth;
+                    int reduce = available * minMaxDiff / logicalWidthBeyondMin;
                     m_layoutStruct[i].computedLogicalWidth += reduce;
                     available -= reduce;
@@ -717 +716 @@
 
         if (available < 0) {
-            LayoutUnit logicalWidthBeyondMin = 0;
+            int logicalWidthBeyondMin = 0;
             for (int i = nEffCols - 1; i >= 0; --i) {
                 Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
@@ -727 +726 @@
                 Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
                 if (logicalWidth.isPercent()) {
-                    LayoutUnit minMaxDiff = m_layoutStruct[i].computedLogicalWidth - m_layoutStruct[i].effectiveMinLogicalWidth;
-                    LayoutUnit reduce = available * minMaxDiff / logicalWidthBeyondMin;
+                    int minMaxDiff = m_layoutStruct[i].computedLogicalWidth - m_layoutStruct[i].effectiveMinLogicalWidth;
+                    int reduce = available * minMaxDiff / logicalWidthBeyondMin;
                     m_layoutStruct[i].computedLogicalWidth += reduce;
                     available -= reduce;
@@ -739 +738 @@
     }
 
-    LayoutUnit pos = 0;
+    int pos = 0;
     for (size_t i = 0; i < nEffCols; ++i) {
         m_table->columnPositions()[i] = pos;

trunk/Source/WebCore/rendering/AutoTableLayout.h

@@ -61 +61 @@
         Length logicalWidth;
         Length effectiveLogicalWidth;
-        LayoutUnit minLogicalWidth;
-        LayoutUnit maxLogicalWidth;
-        LayoutUnit effectiveMinLogicalWidth;
-        LayoutUnit effectiveMaxLogicalWidth;
-        LayoutUnit computedLogicalWidth;
+        int minLogicalWidth;
+        int maxLogicalWidth;
+        int effectiveMinLogicalWidth;
+        int effectiveMaxLogicalWidth;
+        int computedLogicalWidth;
         bool emptyCellsOnly;
     };

trunk/Source/WebCore/rendering/FixedTableLayout.cpp

@@ -195 +195 @@
     //
     // The maximum width is max(minWidth, tableWidth).
-    LayoutUnit bordersPaddingAndSpacing = m_table->bordersPaddingAndSpacingInRowDirection();
-
-    LayoutUnit tableLogicalWidth = m_table->style()->logicalWidth().isFixed() ? m_table->style()->logicalWidth().value() - bordersPaddingAndSpacing : 0;
-    LayoutUnit mw = calcWidthArray(tableLogicalWidth) + bordersPaddingAndSpacing;
+    int bordersPaddingAndSpacing = m_table->bordersPaddingAndSpacingInRowDirection();
+
+    int tableLogicalWidth = m_table->style()->logicalWidth().isFixed() ? m_table->style()->logicalWidth().value() - bordersPaddingAndSpacing : 0;
+    int mw = calcWidthArray(tableLogicalWidth) + bordersPaddingAndSpacing;
 
     minWidth = max(mw, tableLogicalWidth);
@@ -223 +223 @@
 void FixedTableLayout::layout()
 {
-    LayoutUnit tableLogicalWidth = m_table->logicalWidth() - m_table->bordersPaddingAndSpacingInRowDirection();
+    int tableLogicalWidth = m_table->logicalWidth() - m_table->bordersPaddingAndSpacingInRowDirection();
     int nEffCols = m_table->numEffCols();
     Vector<int> calcWidth(nEffCols, 0);
 
     int numAuto = 0;
-    LayoutUnit autoSpan = 0;
-    LayoutUnit totalFixedWidth = 0;
-    LayoutUnit totalPercentWidth = 0;
+    int autoSpan = 0;
+    int totalFixedWidth = 0;
+    int totalPercentWidth = 0;
     float totalPercent = 0;
 
@@ -251 +251 @@
     }
 
-    LayoutUnit hspacing = m_table->hBorderSpacing();
-    LayoutUnit totalWidth = totalFixedWidth + totalPercentWidth;
+    int hspacing = m_table->hBorderSpacing();
+    int totalWidth = totalFixedWidth + totalPercentWidth;
     if (!numAuto || totalWidth > tableLogicalWidth) {
         // If there are no auto columns, or if the total is too wide, take
@@ -280 +280 @@
     } else {
         // Divide the remaining width among the auto columns.
-        LayoutUnit remainingWidth = tableLogicalWidth - totalFixedWidth - totalPercentWidth - hspacing * (autoSpan - numAuto);
+        int remainingWidth = tableLogicalWidth - totalFixedWidth - totalPercentWidth - hspacing * (autoSpan - numAuto);
         int lastAuto = 0;
         for (int i = 0; i < nEffCols; i++) {
             if (m_width[i].isAuto()) {
-                LayoutUnit span = m_table->spanOfEffCol(i);
-                LayoutUnit w = remainingWidth * span / autoSpan;
+                int span = m_table->spanOfEffCol(i);
+                int w = remainingWidth * span / autoSpan;
                 calcWidth[i] = w + hspacing * (span - 1);
                 remainingWidth -= w;
@@ -303 +303 @@
     if (totalWidth < tableLogicalWidth) {
         // Spread extra space over columns.
-        LayoutUnit remainingWidth = tableLogicalWidth - totalWidth;
+        int remainingWidth = tableLogicalWidth - totalWidth;
         int total = nEffCols;
         while (total) {
-            LayoutUnit w = remainingWidth / total;
+            int w = remainingWidth / total;
             remainingWidth -= w;
             calcWidth[--total] += w;
@@ -314 +314 @@
     }
     
-    LayoutUnit pos = 0;
+    int pos = 0;
     for (int i = 0; i < nEffCols; i++) {
         m_table->columnPositions()[i] = pos;
         pos += calcWidth[i] + hspacing;
     }
-    LayoutUnit colPositionsSize = m_table->columnPositions().size();
+    int colPositionsSize = m_table->columnPositions().size();
     if (colPositionsSize > 0)
         m_table->columnPositions()[colPositionsSize - 1] = pos;

trunk/Source/WebCore/rendering/RenderTable.h

@@ -45 +45 @@
     virtual ~RenderTable();
 
-    int getColumnPos(int col) const { return m_columnPos[col]; }
+    LayoutUnit getColumnPos(int col) const { return m_columnPos[col]; }
 
     int hBorderSpacing() const { return m_hSpacing; }
@@ -169 +169 @@
     }
 
-    int bordersPaddingAndSpacingInRowDirection() const
+    LayoutUnit bordersPaddingAndSpacingInRowDirection() const
     {
         return borderStart() + borderEnd() +

trunk/Source/WebCore/rendering/RenderTableCell.cpp

@@ -156 +156 @@
 }
 
-void RenderTableCell::updateLogicalWidth(int w)
+void RenderTableCell::updateLogicalWidth(LayoutUnit w)
 {
     if (w == logicalWidth())
@@ -220 +220 @@
 }
 
-void RenderTableCell::setOverrideHeightFromRowHeight(int rowHeight)
+void RenderTableCell::setOverrideHeightFromRowHeight(LayoutUnit rowHeight)
 {
     clearIntrinsicPadding();
@@ -289 +289 @@
 }
 
-void RenderTableCell::computeRectForRepaint(RenderBoxModelObject* repaintContainer, IntRect& r, bool fixed) const
+void RenderTableCell::computeRectForRepaint(RenderBoxModelObject* repaintContainer, LayoutRect& r, bool fixed) const
 {
     if (repaintContainer == this)
@@ -300 +300 @@
 }
 
-int RenderTableCell::cellBaselinePosition() const
+LayoutUnit RenderTableCell::cellBaselinePosition() const
 {
     // <http://www.w3.org/TR/2007/CR-CSS21-20070719/tables.html#height-layout>: The baseline of a cell is the baseline of
     // the first in-flow line box in the cell, or the first in-flow table-row in the cell, whichever comes first. If there
     // is no such line box or table-row, the baseline is the bottom of content edge of the cell box.
-    int firstLineBaseline = firstLineBoxBaseline();
+    LayoutUnit firstLineBaseline = firstLineBoxBaseline();
     if (firstLineBaseline != -1)
         return firstLineBaseline;
@@ -1037 +1037 @@
 void RenderTableCell::scrollbarsChanged(bool horizontalScrollbarChanged, bool verticalScrollbarChanged)
 {
-    int scrollbarHeight = scrollbarLogicalHeight();
+    LayoutUnit scrollbarHeight = scrollbarLogicalHeight();
     if (!scrollbarHeight)
         return; // Not sure if we should be doing something when a scrollbar goes away or not.

trunk/Source/WebCore/rendering/RenderTableCell.h

@@ -85 +85 @@
     virtual void computePreferredLogicalWidths();
 
-    void updateLogicalWidth(int);
+    void updateLogicalWidth(LayoutUnit);
 
     virtual LayoutUnit borderLeft() const;
@@ -125 +125 @@
     void paintBackgroundsBehindCell(PaintInfo&, const LayoutPoint&, RenderObject* backgroundObject);
 
-    int cellBaselinePosition() const;
+    LayoutUnit cellBaselinePosition() const;
 
     void setIntrinsicPaddingBefore(int p) { m_intrinsicPaddingBefore = p; }
@@ -146 +146 @@
     virtual LayoutUnit paddingAfter(bool includeIntrinsicPadding = true) const;
 
-    void setOverrideHeightFromRowHeight(int);
+    void setOverrideHeightFromRowHeight(LayoutUnit);
 
     virtual void scrollbarsChanged(bool horizontalScrollbarChanged, bool verticalScrollbarChanged);
@@ -170 +170 @@
     virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&) const;
     virtual LayoutRect clippedOverflowRectForRepaint(RenderBoxModelObject* repaintContainer) const;
-    virtual void computeRectForRepaint(RenderBoxModelObject* repaintContainer, IntRect&, bool fixed = false) const;
+    virtual void computeRectForRepaint(RenderBoxModelObject* repaintContainer, LayoutRect&, bool fixed = false) const;
 
     void paintCollapsedBorder(GraphicsContext*, const LayoutRect&);

trunk/Source/WebCore/rendering/RenderTableSection.cpp

@@ -290 +290 @@
                 endCol++;
             }
-            int w = columnPos[endCol] - columnPos[j] - table()->hBorderSpacing();
-            int oldLogicalWidth = cell->logicalWidth();
+            LayoutUnit w = columnPos[endCol] - columnPos[j] - table()->hBorderSpacing();
+            LayoutUnit oldLogicalWidth = cell->logicalWidth();
             if (w != oldLogicalWidth) {
                 cell->setNeedsLayout(true);
@@ -298 +298 @@
                         // Technically, we should also push state for the row, but since
                         // rows don't push a coordinate transform, that's not necessary.
-                        statePusher.push(this, IntSize(x(), y()));
+                        statePusher.push(this, LayoutSize(x(), y()));
                     }
                     cell->repaint();
@@ -464 +464 @@
             LayoutUnit add = 0;
             totalPercent = min(totalPercent, 100);
-            int rh = m_rowPos[1] - m_rowPos[0];
+            LayoutUnit rh = m_rowPos[1] - m_rowPos[0];
             for (unsigned r = 0; r < totalRows; r++) {
                 if (totalPercent > 0 && m_grid[r].logicalHeight.isPercent()) {
-                    LayoutUnit toAdd = min(dh, static_cast<LayoutUnit>((totalHeight * m_grid[r].logicalHeight.percent() / 100) - rh));
+                    LayoutUnit toAdd = min<LayoutUnit>(dh, (totalHeight * m_grid[r].logicalHeight.percent() / 100) - rh);
                     // If toAdd is negative, then we don't want to shrink the row (this bug
                     // affected Outlook Web Access).