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

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

 /*
  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
  *           (C) 1997 Torben Weis (weis@kde.org)
  *           (C) 1998 Waldo Bastian (bastian@kde.org)
  *           (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 192 matching lines @@
   if (!beforeChild)
     setRowLogicalHeightToRowStyleLogicalHeight(m_grid[insertionRow]);
 
   if (beforeChild && beforeChild->parent() != this)
     beforeChild = splitAnonymousBoxesAroundChild(beforeChild);
 
   ASSERT(!beforeChild || beforeChild->isTableRow());
   LayoutTableBoxComponent::addChild(child, beforeChild);
 }
 
 void LayoutTableSection::ensureRows(unsigned numRows) {

[mstensho (USE GERRIT), 2017/01/03 15:18:41]

Could make this inline now, just like ensureCol() is.

[a.suchit, 2017/01/04 10:35:18]

Done.

-  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);
+  if (numRows > m_grid.size())
+    m_grid.grow(numRows);
 }
 
 static inline void checkThatVectorIsDOMOrdered(
     const Vector<LayoutTableCell*, 1>& cells) {
 #ifndef NDEBUG
   // This function should be called on a non-empty vector.
   ASSERT(cells.size() > 0);
 
   const LayoutTableCell* previousCell = cells[0];
   for (size_t i = 1; i < cells.size(); ++i) {
@@ skipping 21 matching lines @@
   // representation will have drifted from the table's representation. Also
   // recalcCells will call addCell at a later time after sync'ing our columns'
   // with the table's.
   if (needsCellRecalc())
     return;
 
   unsigned rSpan = cell->rowSpan();
   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
   // (see the annotation on table cell layouting in the CSS specs and the
   // testcase below:
   // <TABLE border>
   // <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);
 
   ensureRows(insertionRow + rSpan);
 
   m_grid[insertionRow].rowLayoutObject = row;
 
   unsigned col = m_cCol;
   // tell the cell where it is
   bool inColSpan = false;
   while (cSpan) {
     unsigned currentSpan;
-    if (m_cCol >= nCols) {
+    if (m_cCol >= columns.size()) {
       table()->appendEffectiveColumn(cSpan);
       currentSpan = cSpan;
     } else {
       if (cSpan < columns[m_cCol].span)
         table()->splitEffectiveColumn(m_cCol, cSpan);
       currentSpan = columns[m_cCol].span;
     }
     for (unsigned r = 0; r < rSpan; r++) {
+      ensureCol(insertionRow + r, m_cCol);
       CellStruct& c = cellAt(insertionRow + r, m_cCol);
       ASSERT(cell);
       c.cells.append(cell);
       checkThatVectorIsDOMOrdered(c.cells);
       // If cells overlap then we take the slow path for painting.
       if (c.cells.size() > 1)
         m_hasMultipleCellLevels = true;
       if (inColSpan)
         c.inColSpan = true;
     }
@@ skipping 824 matching lines @@
 
   // FIXME: Changing the height without a layout can change the overflow so it
   // seems wrong.
 
   unsigned totalRows = m_grid.size();
 
   // Set the width of our section now.  The rows will also be this width.
   setLogicalWidth(table()->contentLogicalWidth());
 
   int vspacing = table()->vBorderSpacing();
-  unsigned nEffCols = table()->numEffectiveColumns();
   LayoutState state(*this);
 
   // Set the rows' location and size.
   for (unsigned r = 0; r < totalRows; r++) {
     LayoutTableRow* rowLayoutObject = m_grid[r].rowLayoutObject;
     if (rowLayoutObject) {
       rowLayoutObject->setLogicalLocation(LayoutPoint(0, m_rowPos[r]));
       rowLayoutObject->setLogicalWidth(logicalWidth());
       LayoutUnit rowLogicalHeight(m_rowPos[r + 1] - m_rowPos[r] - vspacing);
       if (state.isPaginated() && r + 1 < totalRows) {
         // If the next row has a pagination strut, we need to subtract it. It
         // should not be included in this row's height.
         if (LayoutTableRow* nextRowObject = m_grid[r + 1].rowLayoutObject)
           rowLogicalHeight -= nextRowObject->paginationStrut();
       }
       rowLayoutObject->setLogicalHeight(rowLogicalHeight);
       rowLayoutObject->updateLayerTransformAfterLayout();
     }
   }
 
   // Vertically align and flex the cells in each row.
   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();
 
       if (!cell || cs.inColSpan)
         continue;
 
       if (cell->rowIndex() != r)
         continue;  // Rowspanned cells are handled in the first row they occur.
 
       int rHeight;
@@ skipping 43 matching lines @@
       }
     }
     if (rowLayoutObject)
       rowLayoutObject->computeOverflow();
   }
 
   ASSERT(!needsLayout());
 
   setLogicalHeight(LayoutUnit(m_rowPos[totalRows]));
 
-  computeOverflowFromCells(totalRows, nEffCols);
+  computeOverflowFromCells(totalRows, table()->numEffectiveColumns());
 }
 
 int LayoutTableSection::paginationStrutForRow(LayoutTableRow* row,
                                               LayoutUnit logicalOffset) const {
   DCHECK(row);
   if (row->getPaginationBreakability() == AllowAnyBreaks)
     return 0;
   LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
   if (!pageLogicalHeight)
     return 0;
@@ skipping 35 matching lines @@
           : gMaxAllowedOverflowingCellRatioForFastPaintPath * totalCellsCount;
 
   m_overflow.reset();
   m_overflowingCells.clear();
   m_forceSlowPaintPathWithOverflowingCell = false;
 #if ENABLE(ASSERT)
   bool hasOverflowingCell = false;
 #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)
         continue;
       if (r < totalRows - 1 && cell == primaryCellAt(r + 1, c))
         continue;
       addOverflowFromChild(cell);
 #if ENABLE(ASSERT)
       hasOverflowingCell |= cell->hasVisualOverflow();
 #endif
@@ skipping 12 matching lines @@
     }
   }
 
   ASSERT(hasOverflowingCell == this->hasOverflowingCell());
 }
 
 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);
     if (!rowLayouter ||
         !rowLayouter->childNeedsOverflowRecalcAfterStyleChange())
       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())
         continue;
       rowChildrenOverflowChanged |= cell->recalcOverflowAfterStyleChange();
     }
     if (rowChildrenOverflowChanged)
       rowLayouter->computeOverflow();
     childrenOverflowChanged |= rowChildrenOverflowChanged;
   }
   // TODO(crbug.com/604136): Add visual overflow from rows too.
   if (childrenOverflowChanged)
-    computeOverflowFromCells(totalRows, numEffCols);
+    computeOverflowFromCells(totalRows, table()->numEffectiveColumns());
   return childrenOverflowChanged;
 }
 
 void LayoutTableSection::markAllCellsWidthsDirtyAndOrNeedsLayout(
     LayoutTable::WhatToMarkAllCells whatToMark) {
   for (LayoutTableRow* row = firstRow(); row; row = row->nextRow()) {
     for (LayoutTableCell* cell = row->firstCell(); cell;
          cell = cell->nextCell()) {
       cell->setPreferredLogicalWidthsDirty();
       if (whatToMark == LayoutTable::MarkDirtyAndNeedsLayout)
@@ skipping 19 matching lines @@
 
   const BorderValue& rb = side == BorderBefore
                               ? firstRow()->style()->borderBefore()
                               : lastRow()->style()->borderAfter();
   if (rb.style() == BorderStyleHidden)
     return -1;
   if (rb.style() > BorderStyleHidden && rb.width() > borderWidth)
     borderWidth = rb.width();
 
   bool allHidden = true;
+  unsigned r = side == BorderBefore ? 0 : m_grid.size() - 1;
   for (unsigned c = 0; c < totalCols; c++) {
-    const CellStruct& current =
-        cellAt(side == BorderBefore ? 0 : m_grid.size() - 1, c);
+    if (c >= numCols(r))

[mstensho (USE GERRIT), 2017/01/03 15:18:41]

Might just as well clamp totalCols to numCols(r), so that we don't need this
check.

[a.suchit, 2017/01/04 10:35:18]

Done.

+      break;
+    const CellStruct& current = cellAt(r, c);
     if (current.inColSpan || !current.hasCells())
       continue;
     const ComputedStyle& primaryCellStyle = current.primaryCell()->styleRef();
     // FIXME: Make this work with perpendicular and flipped cells.
     const BorderValue& cb = side == BorderBefore
                                 ? primaryCellStyle.borderBefore()
                                 : primaryCellStyle.borderAfter();
     // FIXME: Don't repeat for the same col group
     LayoutTableCol* col =
         table()->colElementAtAbsoluteColumn(c).innermostColOrColGroup();
@@ skipping 46 matching lines @@
     const BorderValue& gb = side == BorderStart ? col->style()->borderStart()
                                                 : col->style()->borderEnd();
     if (gb.style() == BorderStyleHidden)
       return -1;
     if (gb.style() > BorderStyleHidden && gb.width() > borderWidth)
       borderWidth = gb.width();
   }
 
   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;
     // FIXME: Don't repeat for the same cell
     const ComputedStyle& primaryCellStyle = current.primaryCell()->styleRef();
     const ComputedStyle& primaryCellParentStyle =
         current.primaryCell()->parent()->styleRef();
     // FIXME: Make this work with perpendicular and flipped cells.
     const BorderValue& cb = side == BorderStart ? primaryCellStyle.borderStart()
                                                 : primaryCellStyle.borderEnd();
@@ skipping 231 matching lines @@
 void LayoutTableSection::setNeedsCellRecalc() {
   m_needsCellRecalc = true;
   if (LayoutTable* t = table())
     t->setNeedsSectionRecalc();
 }
 
 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;
     }
   }
 
   return result + 1;
 }
 
 const BorderValue& LayoutTableSection::borderAdjoiningStartCell(
     const LayoutTableCell* cell) const {
   ASSERT(cell->isFirstOrLastCellInRow());
   return hasSameDirectionAs(cell) ? style()->borderStart()
                                   : style()->borderEnd();
 }
 
 const BorderValue& LayoutTableSection::borderAdjoiningEndCell(
     const LayoutTableCell* cell) const {
   ASSERT(cell->isFirstOrLastCellInRow());
   return hasSameDirectionAs(cell) ? style()->borderEnd()
                                   : style()->borderStart();
 }
 
 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) {
   ASSERT(!m_needsCellRecalc);
 
   for (unsigned row = 0; row < m_grid.size(); ++row)
     m_grid[row].row.resize(pos + 1);
 }
 
 void LayoutTableSection::splitEffectiveColumn(unsigned pos, unsigned first) {
   ASSERT(!m_needsCellRecalc);
 
   if (m_cCol > pos)
     m_cCol++;
   for (unsigned row = 0; row < m_grid.size(); ++row) {
     Row& r = m_grid[row].row;
+    ensureCol(row, pos + 1);
     r.insert(pos + 1, CellStruct());
     if (r[pos].hasCells()) {
       r[pos + 1].cells.appendVector(r[pos].cells);
       LayoutTableCell* cell = r[pos].primaryCell();
       ASSERT(cell);
       ASSERT(cell->colSpan() >= (r[pos].inColSpan ? 1u : 0));
       unsigned colleft = cell->colSpan() - r[pos].inColSpan;
       if (first > colleft)
         r[pos + 1].inColSpan = 0;
       else
@@ skipping 47 matching lines @@
 
   LayoutRect tableAlignedRect =
       logicalRectForWritingModeAndDirection(hitTestRect);
   CellSpan rowSpan = spannedRows(tableAlignedRect);
   CellSpan columnSpan = spannedEffectiveColumns(tableAlignedRect);
 
   // Now iterate over the spanned rows and columns.
   for (unsigned hitRow = rowSpan.start(); hitRow < rowSpan.end(); ++hitRow) {
     for (unsigned hitColumn = columnSpan.start(); hitColumn < columnSpan.end();
          ++hitColumn) {
+      if (hitColumn >= numCols(hitRow))
+        continue;

[mstensho (USE GERRIT), 2017/01/03 15:18:41]

Should break instead.

[a.suchit, 2017/01/04 10:35:18]

Done.

+
       CellStruct& current = cellAt(hitRow, hitColumn);
 
       // If the cell is empty, there's nothing to do
       if (!current.hasCells())
         continue;
 
       for (unsigned i = current.cells.size(); i;) {
         --i;
         LayoutTableCell* cell = current.cells[i];
         LayoutPoint cellPoint =
@@ skipping 248 matching lines @@
   // the header in all columns.
   // Note that this is in flow thread coordinates, not visual coordinates. The
   // enclosing LayoutFlowThread will convert to visual coordinates.
   if (table()->header() == this && isRepeatingHeaderGroup())
     rect.setHeight(table()->logicalHeight());
   return LayoutTableBoxComponent::mapToVisualRectInAncestorSpace(ancestor, rect,
                                                                  flags);
 }
 
 }  // namespace blink