Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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 30 matching lines @@
 namespace blink {
 
 using namespace HTMLNames;
 
 // This variable is used to balance the memory consumption vs the paint
 // invalidation time on big tables.
 static unsigned gMinTableSizeToUseFastPaintPathWithOverflowingCell = 75 * 75;
 
 static inline void setRowLogicalHeightToRowStyleLogicalHeight(
     LayoutTableSection::RowStruct& row) {
-  ASSERT(row.rowLayoutObject);
+  DCHECK(row.rowLayoutObject);
   row.logicalHeight = row.rowLayoutObject->style()->logicalHeight();
 }
 
 static inline void updateLogicalHeightForCell(
     LayoutTableSection::RowStruct& row,
     const LayoutTableCell* cell) {
   // We ignore height settings on rowspan cells.
   if (cell->rowSpan() != 1)
     return;
 
@@ skipping 138 matching lines @@
   LayoutTableRow* row = toLayoutTableRow(child);
   m_grid[insertionRow].rowLayoutObject = row;
   row->setRowIndex(insertionRow);
 
   if (!beforeChild)
     setRowLogicalHeightToRowStyleLogicalHeight(m_grid[insertionRow]);
 
   if (beforeChild && beforeChild->parent() != this)
     beforeChild = splitAnonymousBoxesAroundChild(beforeChild);
 
-  ASSERT(!beforeChild || beforeChild->isTableRow());
+  DCHECK(!beforeChild || beforeChild->isTableRow());
   LayoutTableBoxComponent::addChild(child, beforeChild);
 }
 
 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);
+  DCHECK_GT(cells.size(), 0u);
 
   const LayoutTableCell* previousCell = cells[0];
   for (size_t i = 1; i < cells.size(); ++i) {
     const LayoutTableCell* currentCell = cells[i];
     // The check assumes that all cells belong to the same row group.
-    ASSERT(previousCell->section() == currentCell->section());
+    DCHECK_EQ(previousCell->section(), currentCell->section());
 
     // 2 overlapping cells can't be on the same row.
-    ASSERT(currentCell->row() != previousCell->row());
+    DCHECK_NE(currentCell->row(), previousCell->row());
 
     // Look backwards in the tree for the previousCell's row. If we are
     // DOM ordered, we should find it.
     const LayoutTableRow* row = currentCell->row();
     for (; row && row != previousCell->row(); row = row->previousRow()) {
     }
-    ASSERT(row == previousCell->row());
+    DCHECK_EQ(row, previousCell->row());
 
     previousCell = currentCell;
   }
 #endif  // NDEBUG
 }
 
 void LayoutTableSection::addCell(LayoutTableCell* cell, LayoutTableRow* row) {
   // We don't insert the cell if we need cell recalc as our internal columns'
   // representation will have drifted from the table's representation. Also
   // recalcCells will call addCell at a later time after sync'ing our columns'
@@ skipping 38 matching lines @@
       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++) {
       ensureCols(insertionRow + r, m_cCol + 1);
       CellStruct& c = cellAt(insertionRow + r, m_cCol);
-      ASSERT(cell);
+      DCHECK(cell);
       c.cells.push_back(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;
     }
     m_cCol++;
     cSpan -= currentSpan;
@@ skipping 233 matching lines @@
 
   return false;
 }
 
 unsigned LayoutTableSection::calcRowHeightHavingOnlySpanningCells(
     unsigned row,
     int& accumulatedCellPositionIncrease,
     unsigned rowToApplyExtraHeight,
     unsigned& extraTableHeightToPropgate,
     Vector<int>& rowsCountWithOnlySpanningCells) {
-  ASSERT(rowHasOnlySpanningCells(row));
+  DCHECK(rowHasOnlySpanningCells(row));
 
   unsigned totalCols = m_grid[row].row.size();
 
   if (!totalCols)
     return 0;
 
   unsigned rowHeight = 0;
 
   for (unsigned col = 0; col < totalCols; col++) {
     const CellStruct& rowSpanCell = cellAt(row, col);
@@ skipping 41 matching lines @@
   }
 
   return rowHeight;
 }
 
 void LayoutTableSection::updateRowsHeightHavingOnlySpanningCells(
     LayoutTableCell* cell,
     struct SpanningRowsHeight& spanningRowsHeight,
     unsigned& extraHeightToPropagate,
     Vector<int>& rowsCountWithOnlySpanningCells) {
-  ASSERT(spanningRowsHeight.rowHeight.size());
+  DCHECK(spanningRowsHeight.rowHeight.size());
 
   int accumulatedPositionIncrease = 0;
   const unsigned rowSpan = cell->rowSpan();
   const unsigned rowIndex = cell->rowIndex();
 
   DCHECK_EQ(rowSpan, spanningRowsHeight.rowHeight.size());
 
   for (unsigned row = 0; row < spanningRowsHeight.rowHeight.size(); row++) {
     unsigned actualRow = row + rowIndex;
     if (!spanningRowsHeight.rowHeight[row] &&
         rowHasOnlySpanningCells(actualRow)) {
       spanningRowsHeight.rowHeight[row] = calcRowHeightHavingOnlySpanningCells(
           actualRow, accumulatedPositionIncrease, rowIndex + rowSpan,
           extraHeightToPropagate, rowsCountWithOnlySpanningCells);
       accumulatedPositionIncrease += spanningRowsHeight.rowHeight[row];
     }
     m_rowPos[actualRow + 1] += accumulatedPositionIncrease;
   }
 
   spanningRowsHeight.totalRowsHeight += accumulatedPositionIncrease;
 }
 
 // Distribute rowSpan cell height in rows those comes in rowSpan cell based on
 // the ratio of row's height if 1 RowSpan cell height is greater than the total
 // height of rows in rowSpan cell.
 void LayoutTableSection::distributeRowSpanHeightToRows(
     SpanningLayoutTableCells& rowSpanCells) {
-  ASSERT(rowSpanCells.size());
+  DCHECK(rowSpanCells.size());
 
   // 'rowSpanCells' list is already sorted based on the cells rowIndex in
   // ascending order
   // Arrange row spanning cell in the order in which we need to process first.
   std::sort(rowSpanCells.begin(), rowSpanCells.end(),
             compareRowSpanCellsInHeightDistributionOrder);
 
   unsigned extraHeightToPropagate = 0;
   unsigned lastRowIndex = 0;
   unsigned lastRowSpan = 0;
@@ skipping 118 matching lines @@
                                                 extraRowSpanningHeight,
                                                 spanningRowsHeight.rowHeight);
       distributeExtraRowSpanHeightToAutoRows(cell, totalAutoRowsHeight,
                                              extraRowSpanningHeight,
                                              spanningRowsHeight.rowHeight);
       distributeExtraRowSpanHeightToRemainingRows(
           cell, totalRemainingRowsHeight, extraRowSpanningHeight,
           spanningRowsHeight.rowHeight);
     }
 
-    ASSERT(!extraRowSpanningHeight);
+    DCHECK(!extraRowSpanningHeight);
 
     // Getting total changed height in the table
     extraHeightToPropagate =
         m_rowPos[spanningCellEndIndex] - originalBeforePosition;
   }
 
   if (extraHeightToPropagate) {
     // Apply changed height by rowSpan cells to rows present at the end of the
     // table
     for (unsigned row = lastRowIndex + lastRowSpan + 1; row <= m_grid.size();
@@ skipping 32 matching lines @@
         std::max<int>(m_rowPos[row + 1], m_rowPos[row] + m_grid[row].baseline +
                                              cellStartRowBaselineDescent);
   }
 }
 
 int LayoutTableSection::calcRowLogicalHeight() {
 #if DCHECK_IS_ON()
   SetLayoutNeededForbiddenScope layoutForbiddenScope(*this);
 #endif
 
-  ASSERT(!needsLayout());
+  DCHECK(!needsLayout());
 
   LayoutTableCell* cell;
 
   // We may have to forcefully lay out cells here, in which case we need a
   // layout state.
   LayoutState state(*this);
 
   m_rowPos.resize(m_grid.size() + 1);
 
   // We ignore the border-spacing on any non-top section as it is already
@@ skipping 89 matching lines @@
     }
 
     // Add the border-spacing to our final position.
     m_rowPos[r + 1] += borderSpacingForRow(r);
     m_rowPos[r + 1] = std::max(m_rowPos[r + 1], m_rowPos[r]);
   }
 
   if (!rowSpanCells.isEmpty())
     distributeRowSpanHeightToRows(rowSpanCells);
 
-  ASSERT(!needsLayout());
+  DCHECK(!needsLayout());
 
   return m_rowPos[m_grid.size()];
 }
 
 void LayoutTableSection::layout() {
-  ASSERT(needsLayout());
+  DCHECK(needsLayout());
   LayoutAnalyzer::Scope analyzer(*this);
   CHECK(!needsCellRecalc());
-  ASSERT(!table()->needsSectionRecalc());
+  DCHECK(!table()->needsSectionRecalc());
 
   // addChild may over-grow m_grid but we don't want to throw away the memory
   // too early as addChild can be called in a loop (e.g during parsing). Doing
   // it now ensures we have a stable-enough structure.
   m_grid.shrinkToFit();
 
   LayoutState state(*this);
 
   const Vector<int>& columnPos = table()->effectiveColumnPositions();
   LayoutUnit rowLogicalTop;
 
   SubtreeLayoutScope layouter(*this);
   for (unsigned r = 0; r < m_grid.size(); ++r) {
     Row& row = m_grid[r].row;
     unsigned cols = row.size();
     // First, propagate our table layout's information to the cells. This will
     // mark the row as needing layout if there was a column logical width
     // change.
     for (unsigned startColumn = 0; startColumn < cols; ++startColumn) {
       CellStruct& current = row[startColumn];
       LayoutTableCell* cell = current.primaryCell();
       if (!cell || current.inColSpan)
         continue;
 
       unsigned endCol = startColumn;
       unsigned cspan = cell->colSpan();
       while (cspan && endCol < cols) {
-        ASSERT(endCol < table()->effectiveColumns().size());
+        DCHECK_LT(endCol, table()->effectiveColumns().size());
         cspan -= table()->effectiveColumns()[endCol].span;
         endCol++;
       }
       int tableLayoutLogicalWidth = columnPos[endCol] - columnPos[startColumn] -
                                     table()->hBorderSpacing();
       cell->setCellLogicalWidth(tableLayoutLogicalWidth, layouter);
     }
 
     if (LayoutTableRow* rowLayoutObject = m_grid[r].rowLayoutObject) {
       if (state.isPaginated())
@@ skipping 30 matching lines @@
       int toAdd = std::min<int>(
           extraLogicalHeight,
           (totalHeight * m_grid[r].logicalHeight.percent() / 100) - rowHeight);
       // If toAdd is negative, then we don't want to shrink the row (this bug
       // affected Outlook Web Access).
       toAdd = std::max(0, toAdd);
       totalLogicalHeightAdded += toAdd;
       extraLogicalHeight -= toAdd;
       totalPercent -= m_grid[r].logicalHeight.percent();
     }
-    ASSERT(totalRows >= 1);
+    DCHECK_GE(totalRows, 1u);
     if (r < totalRows - 1)
       rowHeight = m_rowPos[r + 2] - m_rowPos[r + 1];
     m_rowPos[r + 1] += totalLogicalHeightAdded;
   }
 }
 
 void LayoutTableSection::distributeExtraLogicalHeightToAutoRows(
     int& extraLogicalHeight,
     unsigned autoRowsCount) {
   if (!autoRowsCount)
@@ skipping 75 matching lines @@
     return true;
   return cellDescendant->isBox() &&
          toLayoutBox(cellDescendant)->shouldBeConsideredAsReplaced();
 }
 
 void LayoutTableSection::layoutRows() {
 #if DCHECK_IS_ON()
   SetLayoutNeededForbiddenScope layoutForbiddenScope(*this);
 #endif
 
-  ASSERT(!needsLayout());
+  DCHECK(!needsLayout());
 
   LayoutAnalyzer::Scope analyzer(*this);
 
   // 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());
@@ skipping 77 matching lines @@
         // need a layout. In this case, we know we're going to issue paint
         // invalidations ourselves (and the child) anyway.
         if (!table()->selfNeedsLayout())
           cell->setMayNeedPaintInvalidation();
       }
     }
     if (rowLayoutObject)
       rowLayoutObject->computeOverflow();
   }
 
-  ASSERT(!needsLayout());
+  DCHECK(!needsLayout());
 
   setLogicalHeight(LayoutUnit(m_rowPos[totalRows]));
 
   computeOverflowFromCells(totalRows, table()->numEffectiveColumns());
 }
 
 int LayoutTableSection::paginationStrutForRow(LayoutTableRow* row,
                                               LayoutUnit logicalOffset) const {
   DCHECK(row);
   if (row->getPaginationBreakability() == AllowAnyBreaks)
@@ skipping 66 matching lines @@
           // overflowing cells as the hit testing code rely on this information.
           m_forceSlowPaintPathWithOverflowingCell = true;
           // The slow path does not make any use of the overflowing cells info,
           // don't hold on to the memory.
           m_overflowingCells.clear();
         }
       }
     }
   }
 
-  ASSERT(hasOverflowingCell == this->hasOverflowingCell());
+#if DCHECK_IS_ON()
+  DCHECK_EQ(hasOverflowingCell, this->hasOverflowingCell());
+#endif
 }
 
 bool LayoutTableSection::recalcChildOverflowAfterStyleChange() {
-  ASSERT(childNeedsOverflowRecalcAfterStyleChange());
+  DCHECK(childNeedsOverflowRecalcAfterStyleChange());
   clearChildNeedsOverflowRecalcAfterStyleChange();
   unsigned totalRows = m_grid.size();
   bool childrenOverflowChanged = false;
   for (unsigned r = 0; r < totalRows; r++) {
     LayoutTableRow* rowLayouter = rowLayoutObjectAt(r);
     if (!rowLayouter ||
         !rowLayouter->childNeedsOverflowRecalcAfterStyleChange())
       continue;
     rowLayouter->clearChildNeedsOverflowRecalcAfterStyleChange();
     bool rowChildrenOverflowChanged = false;
@@ skipping 346 matching lines @@
                                  columnPos.end(), flippedRect.maxX()) -
                 columnPos.begin();
     if (endColumn == columnPos.size())
       endColumn = columnPos.size() - 1;
   }
 
   return CellSpan(startColumn, endColumn);
 }
 
 void LayoutTableSection::recalcCells() {
-  ASSERT(m_needsCellRecalc);
+  DCHECK(m_needsCellRecalc);
   // We reset the flag here to ensure that |addCell| works. This is safe to do
   // as fillRowsWithDefaultStartingAtPosition makes sure we match the table's
   // columns representation.
   m_needsCellRecalc = false;
 
   m_cCol = 0;
   m_cRow = 0;
   m_grid.clear();
 
   for (LayoutTableRow* row = firstRow(); row; row = row->nextRow()) {
@@ skipping 45 matching lines @@
       if (cell.hasCells() || cell.inColSpan)
         result = c;
     }
   }
 
   return result + 1;
 }
 
 const BorderValue& LayoutTableSection::borderAdjoiningStartCell(
     const LayoutTableCell* cell) const {
-  ASSERT(cell->isFirstOrLastCellInRow());
+#if DCHECK_IS_ON()
+  DCHECK(cell->isFirstOrLastCellInRow());
+#endif
   return hasSameDirectionAs(cell) ? style()->borderStart()
                                   : style()->borderEnd();
 }
 
 const BorderValue& LayoutTableSection::borderAdjoiningEndCell(
     const LayoutTableCell* cell) const {
-  ASSERT(cell->isFirstOrLastCellInRow());
+#if DCHECK_IS_ON()
+  DCHECK(cell->isFirstOrLastCellInRow());
+#endif
   return hasSameDirectionAs(cell) ? style()->borderEnd()
                                   : style()->borderStart();
 }
 
 const LayoutTableCell* LayoutTableSection::firstRowCellAdjoiningTableStart()
     const {
   unsigned adjoiningStartCellColumnIndex =
       hasSameDirectionAs(table()) ? 0 : table()->lastEffectiveColumnIndex();
   return primaryCellAt(0, adjoiningStartCellColumnIndex);
 }
@@ skipping 15 matching lines @@
   if (cellStruct.inColSpan)
     return nullptr;
   if (const auto* cell = cellStruct.primaryCell()) {
     if (cell->rowIndex() == row)
       return cell;
   }
   return nullptr;
 }
 
 void LayoutTableSection::appendEffectiveColumn(unsigned pos) {
-  ASSERT(!m_needsCellRecalc);
+  DCHECK(!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);
+  DCHECK(!m_needsCellRecalc);
 
   if (m_cCol > pos)
     m_cCol++;
   for (unsigned row = 0; row < m_grid.size(); ++row) {
     Row& r = m_grid[row].row;
     ensureCols(row, pos + 2);
     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));
+      DCHECK(cell);
+      DCHECK_GE(cell->colSpan(), (r[pos].inColSpan ? 1u : 0));
       unsigned colleft = cell->colSpan() - r[pos].inColSpan;
       if (first > colleft)
         r[pos + 1].inColSpan = 0;
       else
         r[pos + 1].inColSpan = first + r[pos].inColSpan;
     } else {
       r[pos + 1].inColSpan = 0;
     }
   }
 }
@@ skipping 167 matching lines @@
   if (cell.isBaselineAligned()) {
     int baseline = cell.cellBaselinePosition();
     if (baseline > cell.borderBefore() + cell.paddingBefore())
       m_grid[rowIndex].baseline = std::max(m_grid[rowIndex].baseline, baseline);
   }
 }
 
 int LayoutTableSection::logicalHeightForRow(
     const LayoutTableRow& rowObject) const {
   unsigned rowIndex = rowObject.rowIndex();
-  DCHECK(rowIndex < m_grid.size());
+  DCHECK_LT(rowIndex, m_grid.size());
   int logicalHeight = 0;
   const Row& row = m_grid[rowIndex].row;
   unsigned cols = row.size();
   for (unsigned colIndex = 0; colIndex < cols; colIndex++) {
     const CellStruct& cellStruct = cellAt(rowIndex, colIndex);
     const LayoutTableCell* cell = cellStruct.primaryCell();
     if (!cell || cellStruct.inColSpan)
       continue;
     unsigned rowSpan = cell->rowSpan();
     if (rowSpan == 1) {
@@ skipping 126 matching lines @@
     transformState.flatten();
     FloatRect rect = transformState.lastPlanarQuad().boundingBox();
     rect.setHeight(table()->logicalHeight());
     transformState.setQuad(FloatQuad(rect));
   }
   return LayoutTableBoxComponent::mapToVisualRectInAncestorSpaceInternal(
       ancestor, transformState, flags);
 }
 
 }  // namespace blink