Made varied number of cells in each row based on row's requirement.

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

Index: third_party/WebKit/Source/core/layout/LayoutTableSection.cpp
diff --git a/third_party/WebKit/Source/core/layout/LayoutTableSection.cpp b/third_party/WebKit/Source/core/layout/LayoutTableSection.cpp
index 743943848cd72604487ddec936cfc8d786bab25c..8389a7a5b8fe9e56a68f051908468dc167e6465f 100644
--- a/third_party/WebKit/Source/core/layout/LayoutTableSection.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutTableSection.cpp
@@ -210,18 +210,6 @@ void LayoutTableSection::addChild(LayoutObject* child,
   LayoutTableBoxComponent::addChild(child, beforeChild);
 }
 
-void LayoutTableSection::ensureRows(unsigned numRows) {
-  if (numRows <= m_grid.size())
-    return;
-
-  unsigned oldSize = m_grid.size();
-  m_grid.grow(numRows);
-
-  unsigned effectiveColumnCount = std::max(1u, table()->numEffectiveColumns());
-  for (unsigned row = oldSize; row < m_grid.size(); ++row)
-    m_grid[row].row.grow(effectiveColumnCount);
-}
-
 static inline void checkThatVectorIsDOMOrdered(
     const Vector<LayoutTableCell*, 1>& cells) {
 #ifndef NDEBUG
@@ -261,7 +249,6 @@ void LayoutTableSection::addCell(LayoutTableCell* cell, LayoutTableRow* row) {
   unsigned cSpan = cell->colSpan();
   const Vector<LayoutTable::ColumnStruct>& columns =
       table()->effectiveColumns();
-  unsigned nCols = columns.size();
   unsigned insertionRow = row->rowIndex();
 
   // ### mozilla still seems to do the old HTML way, even for strict DTD
@@ -271,8 +258,9 @@ void LayoutTableSection::addCell(LayoutTableCell* cell, LayoutTableRow* row) {
   // <TR><TD>1 <TD rowspan="2">2 <TD>3 <TD>4
   // <TR><TD colspan="2">5
   // </TABLE>
-  while (m_cCol < nCols && (cellAt(insertionRow, m_cCol).hasCells() ||
-                            cellAt(insertionRow, m_cCol).inColSpan))
+  while (m_cCol < numCols(insertionRow) &&
+         (cellAt(insertionRow, m_cCol).hasCells() ||
+          cellAt(insertionRow, m_cCol).inColSpan))
     m_cCol++;
 
   updateLogicalHeightForCell(m_grid[insertionRow], cell);
@@ -286,7 +274,7 @@ void LayoutTableSection::addCell(LayoutTableCell* cell, LayoutTableRow* row) {
   bool inColSpan = false;
   while (cSpan) {
     unsigned currentSpan;
-    if (m_cCol >= nCols) {
+    if (m_cCol >= columns.size()) {
       table()->appendEffectiveColumn(cSpan);
       currentSpan = cSpan;
     } else {
@@ -295,6 +283,7 @@ void LayoutTableSection::addCell(LayoutTableCell* cell, LayoutTableRow* row) {
       currentSpan = columns[m_cCol].span;
     }
     for (unsigned r = 0; r < rSpan; r++) {
+      ensureCols(insertionRow + r, m_cCol + 1);
       CellStruct& c = cellAt(insertionRow + r, m_cCol);
       ASSERT(cell);
       c.cells.append(cell);
@@ -1139,7 +1128,6 @@ void LayoutTableSection::layoutRows() {
   setLogicalWidth(table()->contentLogicalWidth());
 
   int vspacing = table()->vBorderSpacing();
-  unsigned nEffCols = table()->numEffectiveColumns();
   LayoutState state(*this);
 
   // Set the rows' location and size.
@@ -1164,7 +1152,7 @@ void LayoutTableSection::layoutRows() {
   for (unsigned r = 0; r < totalRows; r++) {
     LayoutTableRow* rowLayoutObject = m_grid[r].rowLayoutObject;
 
-    for (unsigned c = 0; c < nEffCols; c++) {
+    for (unsigned c = 0; c < numCols(r); c++) {
       CellStruct& cs = cellAt(r, c);
       LayoutTableCell* cell = cs.primaryCell();
 
@@ -1228,7 +1216,7 @@ void LayoutTableSection::layoutRows() {
 
   setLogicalHeight(LayoutUnit(m_rowPos[totalRows]));
 
-  computeOverflowFromCells(totalRows, nEffCols);
+  computeOverflowFromCells(totalRows, table()->numEffectiveColumns());
 }
 
 int LayoutTableSection::paginationStrutForRow(LayoutTableRow* row,
@@ -1284,7 +1272,7 @@ void LayoutTableSection::computeOverflowFromCells(unsigned totalRows,
 #endif
   // Now that our height has been determined, add in overflow from cells.
   for (unsigned r = 0; r < totalRows; r++) {
-    for (unsigned c = 0; c < nEffCols; c++) {
+    for (unsigned c = 0; c < numCols(r); c++) {
       CellStruct& cs = cellAt(r, c);
       LayoutTableCell* cell = cs.primaryCell();
       if (!cell || cs.inColSpan)
@@ -1317,7 +1305,6 @@ bool LayoutTableSection::recalcChildOverflowAfterStyleChange() {
   ASSERT(childNeedsOverflowRecalcAfterStyleChange());
   clearChildNeedsOverflowRecalcAfterStyleChange();
   unsigned totalRows = m_grid.size();
-  unsigned numEffCols = table()->numEffectiveColumns();
   bool childrenOverflowChanged = false;
   for (unsigned r = 0; r < totalRows; r++) {
     LayoutTableRow* rowLayouter = rowLayoutObjectAt(r);
@@ -1326,7 +1313,7 @@ bool LayoutTableSection::recalcChildOverflowAfterStyleChange() {
       continue;
     rowLayouter->clearChildNeedsOverflowRecalcAfterStyleChange();
     bool rowChildrenOverflowChanged = false;
-    for (unsigned c = 0; c < numEffCols; c++) {
+    for (unsigned c = 0; c < numCols(r); c++) {
       CellStruct& cs = cellAt(r, c);
       LayoutTableCell* cell = cs.primaryCell();
       if (!cell || cs.inColSpan || !cell->needsOverflowRecalcAfterStyleChange())
@@ -1339,7 +1326,7 @@ bool LayoutTableSection::recalcChildOverflowAfterStyleChange() {
   }
   // TODO(crbug.com/604136): Add visual overflow from rows too.
   if (childrenOverflowChanged)
-    computeOverflowFromCells(totalRows, numEffCols);
+    computeOverflowFromCells(totalRows, table()->numEffectiveColumns());
   return childrenOverflowChanged;
 }
 
@@ -1357,8 +1344,7 @@ void LayoutTableSection::markAllCellsWidthsDirtyAndOrNeedsLayout(
 
 int LayoutTableSection::calcBlockDirectionOuterBorder(
     BlockBorderSide side) const {
-  unsigned totalCols = table()->numEffectiveColumns();
-  if (!m_grid.size() || !totalCols)
+  if (!m_grid.size() || !table()->numEffectiveColumns())
     return 0;
 
   int borderWidth = 0;
@@ -1379,9 +1365,9 @@ int LayoutTableSection::calcBlockDirectionOuterBorder(
     borderWidth = rb.width();
 
   bool allHidden = true;
-  for (unsigned c = 0; c < totalCols; c++) {
-    const CellStruct& current =
-        cellAt(side == BorderBefore ? 0 : m_grid.size() - 1, c);
+  unsigned r = side == BorderBefore ? 0 : m_grid.size() - 1;
+  for (unsigned c = 0; c < numCols(r); c++) {
+    const CellStruct& current = cellAt(r, c);
     if (current.inColSpan || !current.hasCells())
       continue;
     const ComputedStyle& primaryCellStyle = current.primaryCell()->styleRef();
@@ -1448,6 +1434,8 @@ int LayoutTableSection::calcInlineDirectionOuterBorder(
 
   bool allHidden = true;
   for (unsigned r = 0; r < m_grid.size(); r++) {
+    if (colIndex >= numCols(r))
+      continue;
     const CellStruct& current = cellAt(r, colIndex);
     if (!current.hasCells())
       continue;
@@ -1699,7 +1687,7 @@ unsigned LayoutTableSection::numEffectiveColumns() const {
   unsigned result = 0;
 
   for (unsigned r = 0; r < m_grid.size(); ++r) {
-    for (unsigned c = result; c < table()->numEffectiveColumns(); ++c) {
+    for (unsigned c = result; c < numCols(r); ++c) {
       const CellStruct& cell = cellAt(r, c);
       if (cell.hasCells() || cell.inColSpan)
         result = c;
@@ -1727,14 +1715,14 @@ const LayoutTableCell* LayoutTableSection::firstRowCellAdjoiningTableStart()
     const {
   unsigned adjoiningStartCellColumnIndex =
       hasSameDirectionAs(table()) ? 0 : table()->lastEffectiveColumnIndex();
-  return cellAt(0, adjoiningStartCellColumnIndex).primaryCell();
+  return primaryCellAt(0, adjoiningStartCellColumnIndex);
 }
 
 const LayoutTableCell* LayoutTableSection::firstRowCellAdjoiningTableEnd()
     const {
   unsigned adjoiningEndCellColumnIndex =
       hasSameDirectionAs(table()) ? table()->lastEffectiveColumnIndex() : 0;
-  return cellAt(0, adjoiningEndCellColumnIndex).primaryCell();
+  return primaryCellAt(0, adjoiningEndCellColumnIndex);
 }
 
 void LayoutTableSection::appendEffectiveColumn(unsigned pos) {
@@ -1751,6 +1739,7 @@ void LayoutTableSection::splitEffectiveColumn(unsigned pos, unsigned first) {
     m_cCol++;
   for (unsigned row = 0; row < m_grid.size(); ++row) {
     Row& r = m_grid[row].row;
+    ensureCols(row, pos + 1 + 1);

[mstensho (USE GERRIT), 2017/01/04 10:56:06]

pos + 2, perhaps? :)

[a.suchit, 2017/01/05 03:34:31]

Done.

[dgrogan, 2017/09/19 00:47:43]

Why is this extra +1 needed? Or, actually, why the ensureCols call at all? The
.insert call on the following line increases the vector length by 1, which
should be sufficient?

I ask because I'm looking at https://crbug.com/761192 , which deals with this
case:

<table>
  <tr>
    <td colspan=5></td>
  </tr>
  <tr>
    <td></td>
  </tr>
</table>

EnsureCols increases the width of the grid cells vector to 2 then the insert
increases it to 3, but there should only be 2 effective columns here.

Morten, how well do you remember this? Suchit is probably going to take a while
to see this email :)

[mstensho (USE GERRIT), 2017/09/19 19:10:26]

Not much at all. :)

According to the WTF::Vector::Insert() documentation, |position| (the index)
must be within bounds, so it does indeed look like this could be necessary,
unless we can tell for sure that pos+1 is within bounds.

[a.suchit2, 2017/09/20 04:52:09]

EnsureCols is used to ensure that insert would be successful for position (pos +
1).

'pos' represents to position(index).
we are trying to insert new column at (current position + 1) so (pos + 1).
As EnsureCols accept the number of columns so number of columns at (pos + 1)
position would be (pos + 1 + 1).

Note : Before this patch EnsureCols was EnsureCol and EnsureCol was accepting
position but EnsureCols accepts number of Columns.

     r.insert(pos + 1, CellStruct());
     if (r[pos].hasCells()) {
       r[pos + 1].cells.appendVector(r[pos].cells);
@@ -1818,6 +1807,9 @@ bool LayoutTableSection::nodeAtPoint(HitTestResult& result,
   for (unsigned hitRow = rowSpan.start(); hitRow < rowSpan.end(); ++hitRow) {
     for (unsigned hitColumn = columnSpan.start(); hitColumn < columnSpan.end();
          ++hitColumn) {
+      if (hitColumn >= numCols(hitRow))
+        break;
+
       CellStruct& current = cellAt(hitRow, hitColumn);
 
       // If the cell is empty, there's nothing to do