RenderTableCell m_row and m_column should not be signed values
authorjchaffraix@webkit.org <jchaffraix@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 28 Oct 2011 01:28:58 +0000 (01:28 +0000)
committerjchaffraix@webkit.org <jchaffraix@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 28 Oct 2011 01:28:58 +0000 (01:28 +0000)
https://bugs.webkit.org/show_bug.cgi?id=70369

Reviewed by Darin Adler.

No new tests, refactoring only.

The gist of the change is to update row / column handling in the table's
rendering code to use unsigned values. Not all the code is switched over
to unsigned but this is a good start.

Using unsigned makes a lot more sense that allowing some negative indexes
to creep in the algorithms. Also it enables us to "free" the unused signed
bit on the 2 RenderTableCell fields that can be used to pack 2 bits in a
follow-up patch.

* accessibility/AccessibilityTable.cpp:
(WebCore::AccessibilityTable::cellForColumnAndRow):
Removed 2 casts to int as the left side now computes to an unsigned too.
Added some ASSERT to make sure we don't get negative values (colSpan / rowSpan
are always >= 1 by definition but better to be safe).

* accessibility/AccessibilityTableColumn.cpp:
(WebCore::AccessibilityTableColumn::headerObjectForSection):
* accessibility/AccessibilityTableColumn.h:
Switched m_columnIndex to unsigned to remove any signed / unsigned comparisons.

* rendering/RenderTable.cpp:
(WebCore::RenderTable::splitColumn):
(WebCore::RenderTable::calcBorderEnd):
(WebCore::RenderTable::cellAbove):
(WebCore::RenderTable::cellBelow):
(WebCore::RenderTable::cellBefore):
(WebCore::RenderTable::cellAfter):
Mostly mechanical changes to avoid signed / unsigned comparisons or casts.

* rendering/RenderTable.h:
(WebCore::RenderTable::numEffCols):
(WebCore::RenderTable::colToEffCol):
Updated a couple of functions to use an unsigned.

* rendering/RenderTableCell.cpp:
(WebCore::RenderTableCell::RenderTableCell):
* rendering/RenderTableCell.h:
(WebCore::RenderTableCell::col):
(WebCore::RenderTableCell::setCol):
(WebCore::RenderTableCell::row):
(WebCore::RenderTableCell::setRow):
Updated after switching the fields to unsigned. Also added 2 constants
to cover the not-initialized-yet value for row and column indexes.
Note: we don't enforce that you can't reach those indexes but neither
did the previous code!

* rendering/RenderTableSection.cpp:
(WebCore::RenderTableSection::RenderTableSection):
(WebCore::RenderTableSection::addChild):
(WebCore::RenderTableSection::ensureRows):
(WebCore::RenderTableSection::setCellLogicalWidths):
(WebCore::RenderTableSection::calcRowLogicalHeight):
(WebCore::RenderTableSection::layoutRows):
(WebCore::RenderTableSection::calcOuterBorderStart):
(WebCore::RenderTableSection::calcOuterBorderEnd):
(WebCore::RenderTableSection::recalcCells):
(WebCore::RenderTableSection::clearGrid):
(WebCore::RenderTableSection::numColumns):
(WebCore::RenderTableSection::appendColumn):
(WebCore::RenderTableSection::splitColumn):
Lots of mechanical: signed -> unsigned changes. However we had
to change the logic a bit as it assumed that m_cRow started at
-1 and increased from there. The new meaning of m_cRow is the
number of rows seen and m_cRow - 1 is where to insert your new
cells.

(WebCore::RenderTableSection::addCell):
Checked the callers and all increase m_cRow before calling the function.
Added an ASSERT to catch up wrong usage in the future.

* rendering/RenderTableSection.h:
(WebCore::RenderTableSection::numRows): Switched to unsigned.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@98676 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebCore/ChangeLog
Source/WebCore/accessibility/AccessibilityTable.cpp
Source/WebCore/accessibility/AccessibilityTableColumn.cpp
Source/WebCore/accessibility/AccessibilityTableColumn.h
Source/WebCore/rendering/RenderTable.cpp
Source/WebCore/rendering/RenderTable.h
Source/WebCore/rendering/RenderTableCell.cpp
Source/WebCore/rendering/RenderTableCell.h
Source/WebCore/rendering/RenderTableSection.cpp
Source/WebCore/rendering/RenderTableSection.h

index 55800a7..09699f6 100755 (executable)
@@ -1,3 +1,85 @@
+2011-10-27  Julien Chaffraix  <jchaffraix@webkit.org>
+
+        RenderTableCell m_row and m_column should not be signed values
+        https://bugs.webkit.org/show_bug.cgi?id=70369
+
+        Reviewed by Darin Adler.
+
+        No new tests, refactoring only.
+
+        The gist of the change is to update row / column handling in the table's
+        rendering code to use unsigned values. Not all the code is switched over
+        to unsigned but this is a good start.
+
+        Using unsigned makes a lot more sense that allowing some negative indexes
+        to creep in the algorithms. Also it enables us to "free" the unused signed
+        bit on the 2 RenderTableCell fields that can be used to pack 2 bits in a
+        follow-up patch.
+
+        * accessibility/AccessibilityTable.cpp:
+        (WebCore::AccessibilityTable::cellForColumnAndRow):
+        Removed 2 casts to int as the left side now computes to an unsigned too.
+        Added some ASSERT to make sure we don't get negative values (colSpan / rowSpan
+        are always >= 1 by definition but better to be safe).
+
+        * accessibility/AccessibilityTableColumn.cpp:
+        (WebCore::AccessibilityTableColumn::headerObjectForSection):
+        * accessibility/AccessibilityTableColumn.h:
+        Switched m_columnIndex to unsigned to remove any signed / unsigned comparisons.
+
+        * rendering/RenderTable.cpp:
+        (WebCore::RenderTable::splitColumn):
+        (WebCore::RenderTable::calcBorderEnd):
+        (WebCore::RenderTable::cellAbove):
+        (WebCore::RenderTable::cellBelow):
+        (WebCore::RenderTable::cellBefore):
+        (WebCore::RenderTable::cellAfter):
+        Mostly mechanical changes to avoid signed / unsigned comparisons or casts.
+
+        * rendering/RenderTable.h:
+        (WebCore::RenderTable::numEffCols):
+        (WebCore::RenderTable::colToEffCol):
+        Updated a couple of functions to use an unsigned.
+
+        * rendering/RenderTableCell.cpp:
+        (WebCore::RenderTableCell::RenderTableCell):
+        * rendering/RenderTableCell.h:
+        (WebCore::RenderTableCell::col):
+        (WebCore::RenderTableCell::setCol):
+        (WebCore::RenderTableCell::row):
+        (WebCore::RenderTableCell::setRow):
+        Updated after switching the fields to unsigned. Also added 2 constants
+        to cover the not-initialized-yet value for row and column indexes.
+        Note: we don't enforce that you can't reach those indexes but neither
+        did the previous code!
+
+        * rendering/RenderTableSection.cpp:
+        (WebCore::RenderTableSection::RenderTableSection):
+        (WebCore::RenderTableSection::addChild):
+        (WebCore::RenderTableSection::ensureRows):
+        (WebCore::RenderTableSection::setCellLogicalWidths):
+        (WebCore::RenderTableSection::calcRowLogicalHeight):
+        (WebCore::RenderTableSection::layoutRows):
+        (WebCore::RenderTableSection::calcOuterBorderStart):
+        (WebCore::RenderTableSection::calcOuterBorderEnd):
+        (WebCore::RenderTableSection::recalcCells):
+        (WebCore::RenderTableSection::clearGrid):
+        (WebCore::RenderTableSection::numColumns):
+        (WebCore::RenderTableSection::appendColumn):
+        (WebCore::RenderTableSection::splitColumn):
+        Lots of mechanical: signed -> unsigned changes. However we had
+        to change the logic a bit as it assumed that m_cRow started at
+        -1 and increased from there. The new meaning of m_cRow is the
+        number of rows seen and m_cRow - 1 is where to insert your new
+        cells.
+
+        (WebCore::RenderTableSection::addCell):
+        Checked the callers and all increase m_cRow before calling the function.
+        Added an ASSERT to catch up wrong usage in the future.
+
+        * rendering/RenderTableSection.h:
+        (WebCore::RenderTableSection::numRows): Switched to unsigned.
+
 2011-10-27  Dan Bernstein  <mitz@apple.com>
 
         Assertion failure (m_text) in RenderText::RenderText() at icanhascheezburger.com
index 65619d0..c836936 100644 (file)
@@ -491,20 +491,22 @@ AccessibilityTableCell* AccessibilityTable::cellForColumnAndRow(unsigned column,
             if (!cell) {
                 
                 // first try rows
-                for (int testRow = sectionSpecificRow-1; testRow >= 0; --testRow) {
+                for (int testRow = sectionSpecificRow - 1; testRow >= 0; --testRow) {
                     cell = tableSection->primaryCellAt(testRow, column);
                     // cell overlapped. use this one
-                    if (cell && ((cell->row() + (cell->rowSpan()-1)) >= (int)sectionSpecificRow))
+                    ASSERT(cell->rowSpan() >= 1);
+                    if (cell && ((cell->row() + (cell->rowSpan() - 1)) >= sectionSpecificRow))
                         break;
                     cell = 0;
                 }
                 
                 if (!cell) {
                     // try cols
-                    for (int testCol = column-1; testCol >= 0; --testCol) {
+                    for (int testCol = column - 1; testCol >= 0; --testCol) {
                         cell = tableSection->primaryCellAt(sectionSpecificRow, testCol);
                         // cell overlapped. use this one
-                        if (cell && ((cell->col() + (cell->colSpan()-1)) >= (int)column))
+                        ASSERT(cell->rowSpan() >= 1);
+                        if (cell && ((cell->col() + (cell->colSpan() - 1)) >= column))
                             break;
                         cell = 0;
                     }
index 581cda5..c94521b 100644 (file)
@@ -122,7 +122,7 @@ AccessibilityObject* AccessibilityTableColumn::headerObjectForSection(RenderTabl
     if (!section)
         return 0;
     
-    int numCols = section->numColumns();
+    unsigned numCols = section->numColumns();
     if (m_columnIndex >= numCols)
         return 0;
     
index a914657..014f32d 100644 (file)
@@ -61,7 +61,7 @@ public:
     virtual LayoutRect elementRect() const;
     
 private:    
-    int m_columnIndex;
+    unsigned m_columnIndex;
     LayoutRect m_columnRect;
     
     AccessibilityObject* headerObjectForSection(RenderTableSection*, bool thTagRequired);
index 5c4dfb1..cd845c9 100644 (file)
@@ -634,21 +634,21 @@ RenderTableSection* RenderTable::topNonEmptySection() const
     return section;
 }
 
-void RenderTable::splitColumn(int pos, int firstSpan)
+void RenderTable::splitColumn(unsigned position, int firstSpan)
 {
     // we need to add a new columnStruct
-    int oldSize = m_columns.size();
+    unsigned oldSize = m_columns.size();
     m_columns.grow(oldSize + 1);
-    int oldSpan = m_columns[pos].span;
+    int oldSpan = m_columns[position].span;
     ASSERT(oldSpan > firstSpan);
-    m_columns[pos].span = firstSpan;
-    memmove(m_columns.data() + pos + 1, m_columns.data() + pos, (oldSize - pos) * sizeof(ColumnStruct));
-    m_columns[pos + 1].span = oldSpan - firstSpan;
+    m_columns[position].span = firstSpan;
+    memmove(m_columns.data() + position + 1, m_columns.data() + position, (oldSize - position) * sizeof(ColumnStruct));
+    m_columns[position + 1].span = oldSpan - firstSpan;
 
     // change width of all rows.
     for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
         if (child->isTableSection())
-            toRenderTableSection(child)->splitColumn(pos, firstSpan);
+            toRenderTableSection(child)->splitColumn(position, firstSpan);
     }
 
     m_columnPos.grow(numEffCols() + 1);
@@ -886,7 +886,7 @@ LayoutUnit RenderTable::calcBorderEnd() const
         if (tb.style() > BHIDDEN)
             borderWidth = tb.width();
 
-        int endColumn = numEffCols() - 1;
+        unsigned endColumn = numEffCols() - 1;
         if (RenderTableCol* colGroup = colElement(endColumn)) {
             const BorderValue& gb = colGroup->style()->borderEnd();
             if (gb.style() == BHIDDEN)
@@ -1103,7 +1103,7 @@ RenderTableCell* RenderTable::cellAbove(const RenderTableCell* cell) const
 
     // Look up the cell in the section's grid, which requires effective col index
     if (section) {
-        int effCol = colToEffCol(cell->col());
+        unsigned effCol = colToEffCol(cell->col());
         RenderTableSection::CellStruct& aboveCell = section->cellAt(rAbove, effCol);
         return aboveCell.primaryCell();
     } else
@@ -1115,9 +1115,9 @@ RenderTableCell* RenderTable::cellBelow(const RenderTableCell* cell) const
     recalcSectionsIfNeeded();
 
     // Find the section and row to look in
-    int r = cell->row() + cell->rowSpan() - 1;
+    unsigned r = cell->row() + cell->rowSpan() - 1;
     RenderTableSection* section = 0;
-    int rBelow = 0;
+    unsigned rBelow = 0;
     if (r < cell->section()->numRows() - 1) {
         // The cell is not in the last row, so use the next row in the section.
         section = cell->section();
@@ -1130,7 +1130,7 @@ RenderTableCell* RenderTable::cellBelow(const RenderTableCell* cell) const
 
     // Look up the cell in the section's grid, which requires effective col index
     if (section) {
-        int effCol = colToEffCol(cell->col());
+        unsigned effCol = colToEffCol(cell->col());
         RenderTableSection::CellStruct& belowCell = section->cellAt(rBelow, effCol);
         return belowCell.primaryCell();
     } else
@@ -1142,7 +1142,7 @@ RenderTableCell* RenderTable::cellBefore(const RenderTableCell* cell) const
     recalcSectionsIfNeeded();
 
     RenderTableSection* section = cell->section();
-    int effCol = colToEffCol(cell->col());
+    unsigned effCol = colToEffCol(cell->col());
     if (!effCol)
         return 0;
     
@@ -1155,7 +1155,7 @@ RenderTableCell* RenderTable::cellAfter(const RenderTableCell* cell) const
 {
     recalcSectionsIfNeeded();
 
-    int effCol = colToEffCol(cell->col() + cell->colSpan());
+    unsigned effCol = colToEffCol(cell->col() + cell->colSpan());
     if (effCol >= numEffCols())
         return 0;
     return cell->section()->primaryCellAt(cell->row(), effCol);
index 8a6433c..c19d635 100644 (file)
@@ -146,18 +146,18 @@ public:
     // This function returns 0 if the table has no non-empty sections.
     RenderTableSection* topNonEmptySection() const;
 
-    void splitColumn(int pos, int firstSpan);
+    void splitColumn(unsigned position, int firstSpan);
     void appendColumn(int span);
-    int numEffCols() const { return m_columns.size(); }
+    unsigned numEffCols() const { return m_columns.size(); }
     int spanOfEffCol(int effCol) const { return m_columns[effCol].span; }
     
-    int colToEffCol(unsigned col) const
+    unsigned colToEffCol(unsigned column) const
     {
-        unsigned effCol = 0;
-        unsigned numCols = numEffCols();
-        for (unsigned c = 0; effCol < numCols && c + m_columns[effCol].span - 1 < col; ++effCol)
-            c += m_columns[effCol].span;
-        return effCol;
+        unsigned effColumn = 0;
+        unsigned numColumns = numEffCols();
+        for (unsigned c = 0; effColumn < numColumns && c + m_columns[effColumn].span - 1 < column; ++effColumn)
+            c += m_columns[effColumn].span;
+        return effColumn;
     }
     
     int effColToCol(int effCol) const
index fdb45db..61e4788 100644 (file)
@@ -43,8 +43,8 @@ using namespace HTMLNames;
 
 RenderTableCell::RenderTableCell(Node* node)
     : RenderBlock(node)
-    , m_row(-1)
-    , m_column(-1)
+    , m_row(unsetRowIndex)
+    , m_column(unsetColumnIndex)
     , m_intrinsicPaddingBefore(0)
     , m_intrinsicPaddingAfter(0)
     , m_cellWidthChanged(false)
index 755a854..e7142df 100644 (file)
 
 namespace WebCore {
 
+// FIXME: It is possible for these indexes to be reached for a table big enough.
+// We would need to enforce a maximal index on both rows and columns.
+static const unsigned unsetColumnIndex = 0xFFFFFFFF;
+static const unsigned unsetRowIndex = 0xFFFFFFFF;
+
 class RenderTableCell : public RenderBlock {
 public:
     explicit RenderTableCell(Node*);
@@ -43,10 +48,19 @@ public:
     // Called from HTMLTableCellElement.
     void colSpanOrRowSpanChanged();
 
-    int col() const { return m_column; }
-    void setCol(int col) { m_column = col; }
-    int row() const { return m_row; }
-    void setRow(int row) { m_row = row; }
+    void setCol(unsigned column) { m_column = column; }
+    unsigned col() const
+    {
+        ASSERT(m_column != unsetColumnIndex);
+        return m_column;
+    }
+
+    void setRow(unsigned row) { m_row = row; }
+    unsigned row() const
+    {
+        ASSERT(m_row != unsetRowIndex);
+        return m_row;
+    }
 
     RenderTableSection* section() const { return toRenderTableSection(parent()->parent()); }
     RenderTable* table() const { return toRenderTable(parent()->parent()->parent()); }
@@ -145,8 +159,8 @@ private:
 
     void paintCollapsedBorder(GraphicsContext*, const LayoutRect&);
 
-    int m_row;
-    int m_column;
+    unsigned m_row;
+    unsigned m_column;
     int m_intrinsicPaddingBefore;
     int m_intrinsicPaddingAfter;
 
index 075f87d..0f8434e 100644 (file)
@@ -59,7 +59,7 @@ static inline void setRowLogicalHeightToRowStyleLogicalHeightIfNotRelative(Rende
 RenderTableSection::RenderTableSection(Node* node)
     : RenderBox(node)
     , m_cCol(0)
-    , m_cRow(-1)
+    , m_cRow(0)
     , m_outerBorderStart(0)
     , m_outerBorderEnd(0)
     , m_outerBorderBefore(0)
@@ -147,17 +147,18 @@ void RenderTableSection::addChild(RenderObject* child, RenderObject* beforeChild
     if (beforeChild)
         setNeedsCellRecalc();
 
+    unsigned insertionRow = m_cRow;
     ++m_cRow;
     m_cCol = 0;
 
     // make sure we have enough rows
-    if (!ensureRows(m_cRow + 1))
+    if (!ensureRows(m_cRow))
         return;
 
-    m_grid[m_cRow].rowRenderer = toRenderTableRow(child);
+    m_grid[insertionRow].rowRenderer = toRenderTableRow(child);
 
     if (!beforeChild)
-        setRowLogicalHeightToRowStyleLogicalHeightIfNotRelative(&m_grid[m_cRow]);
+        setRowLogicalHeightToRowStyleLogicalHeightIfNotRelative(&m_grid[insertionRow]);
 
     // If the next renderer is actually wrapped in an anonymous table row, we need to go up and find that.
     while (beforeChild && beforeChild->parent() != this)
@@ -174,9 +175,9 @@ void RenderTableSection::removeChild(RenderObject* oldChild)
     RenderBox::removeChild(oldChild);
 }
 
-bool RenderTableSection::ensureRows(int numRows)
+bool RenderTableSection::ensureRows(unsigned numRows)
 {
-    if (numRows > static_cast<int>(m_grid.size())) {
+    if (numRows > m_grid.size()) {
         size_t maxSize = numeric_limits<size_t>::max() / sizeof(RowStruct);
         if (static_cast<size_t>(numRows) > maxSize)
             return false;
@@ -184,8 +185,8 @@ bool RenderTableSection::ensureRows(int numRows)
         unsigned oldSize = m_grid.size();
         m_grid.grow(numRows);
 
-        int nCols = max(1, table()->numEffCols());
-        for (int r = oldSize; r < numRows; r++) {
+        unsigned nCols = max(1u, table()->numEffCols());
+        for (unsigned r = oldSize; r < numRows; r++) {
             m_grid[r].row = new Row(nCols);
             m_grid[r].rowRenderer = 0;
             m_grid[r].baseline = 0;
@@ -201,7 +202,10 @@ void RenderTableSection::addCell(RenderTableCell* cell, RenderTableRow* row)
     int rSpan = cell->rowSpan();
     int cSpan = cell->colSpan();
     Vector<RenderTable::ColumnStruct>& columns = table()->columns();
-    int nCols = columns.size();
+    unsigned nCols = columns.size();
+    // addCell should be called only after m_cRow has been incremented.
+    ASSERT(m_cRow);
+    unsigned insertionRow = m_cRow - 1;
 
     // ### mozilla still seems to do the old HTML way, even for strict DTD
     // (see the annotation on table cell layouting in the CSS specs and the testcase below:
@@ -209,24 +213,24 @@ void RenderTableSection::addCell(RenderTableCell* cell, RenderTableRow* row)
     // <TR><TD>1 <TD rowspan="2">2 <TD>3 <TD>4
     // <TR><TD colspan="2">5
     // </TABLE>
-    while (m_cCol < nCols && (cellAt(m_cRow, m_cCol).hasCells() || cellAt(m_cRow, m_cCol).inColSpan))
+    while (m_cCol < nCols && (cellAt(insertionRow, m_cCol).hasCells() || cellAt(insertionRow, m_cCol).inColSpan))
         m_cCol++;
 
     if (rSpan == 1) {
         // we ignore height settings on rowspan cells
         Length logicalHeight = cell->style()->logicalHeight();
         if (logicalHeight.isPositive() || (logicalHeight.isRelative() && logicalHeight.value() >= 0)) {
-            Length cRowLogicalHeight = m_grid[m_cRow].logicalHeight;
+            Length cRowLogicalHeight = m_grid[insertionRow].logicalHeight;
             switch (logicalHeight.type()) {
                 case Percent:
                     if (!(cRowLogicalHeight.isPercent()) ||
                         (cRowLogicalHeight.isPercent() && cRowLogicalHeight.percent() < logicalHeight.percent()))
-                        m_grid[m_cRow].logicalHeight = logicalHeight;
+                        m_grid[insertionRow].logicalHeight = logicalHeight;
                         break;
                 case Fixed:
                     if (cRowLogicalHeight.type() < Percent ||
                         (cRowLogicalHeight.isFixed() && cRowLogicalHeight.value() < logicalHeight.value()))
-                        m_grid[m_cRow].logicalHeight = logicalHeight;
+                        m_grid[insertionRow].logicalHeight = logicalHeight;
                     break;
                 case Relative:
                 default:
@@ -236,12 +240,12 @@ void RenderTableSection::addCell(RenderTableCell* cell, RenderTableRow* row)
     }
 
     // make sure we have enough rows
-    if (!ensureRows(m_cRow + rSpan))
+    if (!ensureRows(insertionRow + rSpan))
         return;
 
-    m_grid[m_cRow].rowRenderer = row;
+    m_grid[insertionRow].rowRenderer = row;
 
-    int col = m_cCol;
+    unsigned col = m_cCol;
     // tell the cell where it is
     bool inColSpan = false;
     while (cSpan) {
@@ -255,7 +259,7 @@ void RenderTableSection::addCell(RenderTableCell* cell, RenderTableRow* row)
             currentSpan = columns[m_cCol].span;
         }
         for (int r = 0; r < rSpan; r++) {
-            CellStruct& c = cellAt(m_cRow + r, m_cCol);
+            CellStruct& c = cellAt(insertionRow + r, m_cCol);
             ASSERT(cell);
             c.cells.append(cell);
             // If cells overlap then we take the slow path for painting.
@@ -268,7 +272,7 @@ void RenderTableSection::addCell(RenderTableCell* cell, RenderTableRow* row)
         cSpan -= currentSpan;
         inColSpan = true;
     }
-    cell->setRow(m_cRow);
+    cell->setRow(insertionRow);
     cell->setCol(table()->effColToCol(col));
 }
 
@@ -280,16 +284,16 @@ void RenderTableSection::setCellLogicalWidths()
 
     for (unsigned i = 0; i < m_grid.size(); i++) {
         Row& row = *m_grid[i].row;
-        int cols = row.size();
-        for (int j = 0; j < cols; j++) {
+        unsigned cols = row.size();
+        for (unsigned j = 0; j < cols; j++) {
             CellStruct& current = row[j];
             RenderTableCell* cell = current.primaryCell();
             if (!cell || current.inColSpan)
               continue;
-            int endCol = j;
+            unsigned endCol = j;
             int cspan = cell->colSpan();
             while (cspan && endCol < cols) {
-                ASSERT(endCol < (int)table()->columns().size());
+                ASSERT(endCol < table()->columns().size());
                 cspan -= table()->columns()[endCol].span;
                 endCol++;
             }
@@ -341,16 +345,16 @@ LayoutUnit RenderTableSection::calcRowLogicalHeight()
         m_rowPos[r + 1] = max(m_rowPos[r + 1], pos);
 
         Row* row = m_grid[r].row;
-        int totalCols = row->size();
+        unsigned totalCols = row->size();
 
-        for (int c = 0; c < totalCols; c++) {
+        for (unsigned c = 0; c < totalCols; c++) {
             CellStruct& current = cellAt(r, c);
             cell = current.primaryCell();
 
             if (!cell || current.inColSpan)
                 continue;
 
-            if ((cell->row() + cell->rowSpan() - 1) > static_cast<int>(r))
+            if ((cell->row() + cell->rowSpan() - 1) > r)
                 continue;
 
             unsigned indx = max(r - cell->rowSpan() + 1, 0u);
@@ -439,8 +443,8 @@ LayoutUnit RenderTableSection::layoutRows(LayoutUnit toAdd)
 
     LayoutUnit rHeight;
     int rindx;
-    int totalRows = m_grid.size();
-    
+    unsigned totalRows = m_grid.size();
+
     // Set the width of our section now.  The rows will also be this width.
     setLogicalWidth(table()->contentLogicalWidth());
     m_overflow.clear();
@@ -453,7 +457,7 @@ LayoutUnit RenderTableSection::layoutRows(LayoutUnit toAdd)
         LayoutUnit dh = toAdd;
         int totalPercent = 0;
         int numAuto = 0;
-        for (int r = 0; r < totalRows; r++) {
+        for (unsigned r = 0; r < totalRows; r++) {
             if (m_grid[r].logicalHeight.isAuto())
                 numAuto++;
             else if (m_grid[r].logicalHeight.isPercent())
@@ -464,7 +468,7 @@ LayoutUnit RenderTableSection::layoutRows(LayoutUnit toAdd)
             LayoutUnit add = 0;
             totalPercent = min(totalPercent, 100);
             int rh = m_rowPos[1] - m_rowPos[0];
-            for (int r = 0; r < totalRows; r++) {
+            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));
                     // If toAdd is negative, then we don't want to shrink the row (this bug
@@ -474,6 +478,7 @@ LayoutUnit RenderTableSection::layoutRows(LayoutUnit toAdd)
                     dh -= toAdd;
                     totalPercent -= m_grid[r].logicalHeight.percent();
                 }
+                ASSERT(totalRows >= 1);
                 if (r < totalRows - 1)
                     rh = m_rowPos[r + 2] - m_rowPos[r + 1];
                 m_rowPos[r + 1] += add;
@@ -482,7 +487,7 @@ LayoutUnit RenderTableSection::layoutRows(LayoutUnit toAdd)
         if (numAuto) {
             // distribute over variable cols
             LayoutUnit add = 0;
-            for (int r = 0; r < totalRows; r++) {
+            for (unsigned r = 0; r < totalRows; r++) {
                 if (numAuto > 0 && m_grid[r].logicalHeight.isAuto()) {
                     LayoutUnit toAdd = dh / numAuto;
                     add += toAdd;
@@ -497,7 +502,7 @@ LayoutUnit RenderTableSection::layoutRows(LayoutUnit toAdd)
             LayoutUnit tot = m_rowPos[totalRows];
             LayoutUnit add = 0;
             LayoutUnit prev = m_rowPos[0];
-            for (int r = 0; r < totalRows; r++) {
+            for (unsigned r = 0; r < totalRows; r++) {
                 // weight with the original height
                 add += dh * (m_rowPos[r + 1] - prev) / tot;
                 prev = m_rowPos[r + 1];
@@ -512,7 +517,7 @@ LayoutUnit RenderTableSection::layoutRows(LayoutUnit toAdd)
 
     LayoutStateMaintainer statePusher(view(), this, LayoutSize(x(), y()), style()->isFlippedBlocksWritingMode());
 
-    for (int r = 0; r < totalRows; r++) {
+    for (unsigned r = 0; r < totalRows; r++) {
         // Set the row's x/y position and width/height.
         if (RenderTableRow* rowRenderer = m_grid[r].rowRenderer) {
             rowRenderer->setLocation(LayoutPoint(0, m_rowPos[r]));
@@ -677,7 +682,7 @@ LayoutUnit RenderTableSection::layoutRows(LayoutUnit toAdd)
     bool hasOverflowingCell = false;
 #endif
     // Now that our height has been determined, add in overflow from cells.
-    for (int r = 0; r < totalRows; r++) {
+    for (unsigned r = 0; r < totalRows; r++) {
         for (int c = 0; c < nEffCols; c++) {
             CellStruct& cs = cellAt(r, c);
             RenderTableCell* cell = cs.primaryCell();
@@ -1122,7 +1127,7 @@ void RenderTableSection::imageChanged(WrappedImagePtr, const IntRect*)
 void RenderTableSection::recalcCells()
 {
     m_cCol = 0;
-    m_cRow = -1;
+    m_cRow = 0;
     unsigned capacity = m_grid.size();
     clearGrid();
     // Although it is possible for our row count to shrink (due to removeChild being called),
@@ -1132,14 +1137,15 @@ void RenderTableSection::recalcCells()
 
     for (RenderObject* row = firstChild(); row; row = row->nextSibling()) {
         if (row->isTableRow()) {
+            unsigned insertionRow = m_cRow;
             m_cRow++;
             m_cCol = 0;
-            if (!ensureRows(m_cRow + 1))
+            if (!ensureRows(m_cRow))
                 break;
             
             RenderTableRow* tableRow = toRenderTableRow(row);
-            m_grid[m_cRow].rowRenderer = tableRow;
-            setRowLogicalHeightToRowStyleLogicalHeightIfNotRelative(&m_grid[m_cRow]);
+            m_grid[insertionRow].rowRenderer = tableRow;
+            setRowLogicalHeightToRowStyleLogicalHeightIfNotRelative(&m_grid[insertionRow]);
 
             for (RenderObject* cell = row->firstChild(); cell; cell = cell->nextSibling()) {
                 if (cell->isTableCell())
@@ -1166,12 +1172,12 @@ void RenderTableSection::clearGrid()
     m_grid.clear();
 }
 
-int RenderTableSection::numColumns() const
+unsigned RenderTableSection::numColumns() const
 {
-    int result = 0;
+    unsigned result = 0;
     
     for (unsigned r = 0; r < m_grid.size(); ++r) {
-        for (int c = result; c < table()->numEffCols(); ++c) {
+        for (unsigned c = result; c < table()->numEffCols(); ++c) {
             const CellStruct& cell = cellAt(r, c);
             if (cell.hasCells() || cell.inColSpan)
                 result = c;
@@ -1187,7 +1193,7 @@ void RenderTableSection::appendColumn(int pos)
         m_grid[row].row->resize(pos + 1);
 }
 
-void RenderTableSection::splitColumn(int pos, int first)
+void RenderTableSection::splitColumn(unsigned pos, int first)
 {
     ASSERT(!m_needsCellRecalc);
 
index 4261cae..1f543fa 100644 (file)
@@ -92,7 +92,7 @@ public:
     }
 
     void appendColumn(int pos);
-    void splitColumn(int pos, int first);
+    void splitColumn(unsigned pos, int first);
 
     LayoutUnit calcOuterBorderBefore() const;
     LayoutUnit calcOuterBorderAfter() const;
@@ -105,8 +105,8 @@ public:
     LayoutUnit outerBorderStart() const { return m_outerBorderStart; }
     LayoutUnit outerBorderEnd() const { return m_outerBorderEnd; }
 
-    int numRows() const { return m_grid.size(); }
-    int numColumns() const;
+    unsigned numRows() const { return m_grid.size(); }
+    unsigned numColumns() const;
     void recalcCells();
     void recalcCellsIfNeeded()
     {
@@ -144,7 +144,7 @@ private:
 
     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
 
-    bool ensureRows(int);
+    bool ensureRows(unsigned);
     void clearGrid();
 
     bool hasOverflowingCell() const { return m_overflowingCells.size() || m_forceSlowPaintPathWithOverflowingCell; }
@@ -155,8 +155,8 @@ private:
     Vector<LayoutUnit> m_rowPos;
 
     // the current insertion position
-    int m_cCol;
-    int m_cRow;
+    unsigned m_cCol;
+    unsigned m_cRow;
 
     LayoutUnit m_outerBorderStart;
     LayoutUnit m_outerBorderEnd;