Replace ASSERT with DCHECK in core/layout/ excluding subdirs

third_party/WebKit/Source/core/layout/LayoutTable.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, 2007, 2008, 2009, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 49 matching lines @@
       m_collapsedBordersValid(false),
       m_hasColElements(false),
       m_needsSectionRecalc(false),
       m_columnLogicalWidthChanged(false),
       m_columnLayoutObjectsValid(false),
       m_noCellColspanAtLeast(0),
       m_hSpacing(0),
       m_vSpacing(0),
       m_borderStart(0),
       m_borderEnd(0) {
-  ASSERT(!childrenInline());
+  DCHECK(!childrenInline());
   m_effectiveColumnPositions.fill(0, 1);
 }
 
 LayoutTable::~LayoutTable() {}
 
 void LayoutTable::styleDidChange(StyleDifference diff,
                                  const ComputedStyle* oldStyle) {
   LayoutBlock::styleDidChange(diff, oldStyle);
 
   bool oldFixedTableLayout = oldStyle ? oldStyle->isFixedTableLayout() : false;
@@ skipping 127 matching lines @@
       needsTableSection(beforeChild))
     beforeChild = 0;
 
   LayoutTableSection* section =
       LayoutTableSection::createAnonymousWithParent(this);
   addChild(section, beforeChild);
   section->addChild(child);
 }
 
 void LayoutTable::addCaption(const LayoutTableCaption* caption) {
-  ASSERT(m_captions.find(caption) == kNotFound);
+  DCHECK_EQ(m_captions.find(caption), kNotFound);
   m_captions.push_back(const_cast<LayoutTableCaption*>(caption));
 }
 
 void LayoutTable::removeCaption(const LayoutTableCaption* oldCaption) {
   size_t index = m_captions.find(oldCaption);
-  ASSERT(index != kNotFound);
+  DCHECK_NE(index, kNotFound);
   if (index == kNotFound)
     return;
 
   m_captions.erase(index);
 }
 
 void LayoutTable::invalidateCachedColumns() {
   m_columnLayoutObjectsValid = false;
   m_columnLayoutObjects.resize(0);
 }
@@ skipping 112 matching lines @@
                              marginValues.m_end, style()->marginStart(),
                              style()->marginEnd());
   setMarginStart(marginValues.m_start);
   setMarginEnd(marginValues.m_end);
 
   // We should NEVER shrink the table below the min-content logical width, or
   // else the table can't accommodate its own content which doesn't match CSS
   // nor what authors expect.
   // FIXME: When we convert to sub-pixel layout for tables we can remove the int
   // conversion. http://crbug.com/241198
-  ASSERT(logicalWidth().floor() >= minPreferredLogicalWidth().floor());
+  DCHECK_GE(logicalWidth().floor(), minPreferredLogicalWidth().floor());
 }
 
 // This method takes a ComputedStyle's logical width, min-width, or max-width
 // length and computes its actual value.
 LayoutUnit LayoutTable::convertStyleLogicalWidthToComputedWidth(
     const Length& styleLogicalWidth,
     LayoutUnit availableWidth) const {
   if (styleLogicalWidth.isIntrinsic())
     return computeIntrinsicLogicalWidthUsing(
         styleLogicalWidth, availableWidth,
@@ skipping 134 matching lines @@
   // FIXME: Distribute the extra logical height between all table sections
   // instead of giving it all to the first one.
   if (LayoutTableSection* section = firstBody())
     extraLogicalHeight -=
         section->distributeExtraLogicalHeightToRows(extraLogicalHeight);
 
   // crbug.com/690087: We really would like to enable this ASSERT to ensure that
   // all the extra space has been distributed.
   // However our current distribution algorithm does not round properly and thus
   // we can have some remaining height.
-  // ASSERT(!topSection() || !extraLogicalHeight);
+  // DCHECK(!topSection() || !extraLogicalHeight);
 }
 
 void LayoutTable::simplifiedNormalFlowLayout() {
   // FIXME: We should walk through the items in the tree in tree order to do the
   // layout here instead of walking through individual parts of the tree.
   // crbug.com/442737
   for (auto& caption : m_captions)
     caption->layoutIfNeeded();
 
   for (LayoutTableSection* section = topSection(); section;
        section = sectionBelow(section)) {
     section->layoutIfNeeded();
     section->layoutRows();
     section->computeOverflowFromCells();
     section->updateLayerTransformAfterLayout();
     section->addVisualEffectOverflow();
   }
 }
 
 bool LayoutTable::recalcChildOverflowAfterStyleChange() {
-  ASSERT(childNeedsOverflowRecalcAfterStyleChange());
+  DCHECK(childNeedsOverflowRecalcAfterStyleChange());
   clearChildNeedsOverflowRecalcAfterStyleChange();
 
   // If the table sections we keep pointers to have gone away then the table
   // will be rebuilt and overflow will get recalculated anyway so return early.
   if (needsSectionRecalc())
     return false;
 
   bool childrenOverflowChanged = false;
   for (LayoutTableSection* section = topSection(); section;
        section = sectionBelow(section)) {
     if (!section->childNeedsOverflowRecalcAfterStyleChange())
       continue;
     childrenOverflowChanged = section->recalcChildOverflowAfterStyleChange() ||
                               childrenOverflowChanged;
   }
   return recalcPositionedDescendantsOverflowAfterStyleChange() ||
          childrenOverflowChanged;
 }
 
 void LayoutTable::layout() {
-  ASSERT(needsLayout());
+  DCHECK(needsLayout());
   LayoutAnalyzer::Scope analyzer(*this);
 
   if (simplifiedLayout())
     return;
 
   // Note: LayoutTable is handled differently than other LayoutBlocks and the
   // LayoutScope
   //       must be created before the table begins laying out.
   TextAutosizer::LayoutScope textAutosizerLayoutScope(this);
 
@@ skipping 217 matching lines @@
   m_collapsedBordersValid = true;
   m_collapsedBorders.clear();
   for (LayoutObject* section = firstChild(); section;
        section = section->nextSibling()) {
     if (!section->isTableSection())
       continue;
     for (LayoutTableRow* row = toLayoutTableSection(section)->firstRow(); row;
          row = row->nextRow()) {
       for (LayoutTableCell* cell = row->firstCell(); cell;
            cell = cell->nextCell()) {
-        ASSERT(cell->table() == this);
+        DCHECK_EQ(cell->table(), this);
         cell->collectBorderValues(m_collapsedBorders);
       }
     }
   }
   LayoutTableCell::sortBorderValues(m_collapsedBorders);
 }
 
 void LayoutTable::addOverflowFromChildren() {
   // Add overflow from borders.
   // Technically it's odd that we are incorporating the borders into layout
@@ skipping 86 matching lines @@
   // FIXME: Restructure the table layout code so that we can make this method
   // const.
   const_cast<LayoutTable*>(this)->m_tableLayout->computeIntrinsicLogicalWidths(
       minWidth, maxWidth);
 
   // FIXME: We should include captions widths here like we do in
   // computePreferredLogicalWidths.
 }
 
 void LayoutTable::computePreferredLogicalWidths() {
-  ASSERT(preferredLogicalWidthsDirty());
+  DCHECK(preferredLogicalWidthsDirty());
 
   computeIntrinsicLogicalWidths(m_minPreferredLogicalWidth,
                                 m_maxPreferredLogicalWidth);
 
   int bordersPaddingAndSpacing =
       bordersPaddingAndSpacingInRowDirection().toInt();
   m_minPreferredLogicalWidth += bordersPaddingAndSpacing;
   m_maxPreferredLogicalWidth += bordersPaddingAndSpacing;
 
   m_tableLayout->applyPreferredLogicalWidthQuirks(m_minPreferredLogicalWidth,
@@ skipping 36 matching lines @@
 
 LayoutTableSection* LayoutTable::topNonEmptySection() const {
   LayoutTableSection* section = topSection();
   if (section && !section->numRows())
     section = sectionBelow(section, SkipEmptySections);
   return section;
 }
 
 void LayoutTable::splitEffectiveColumn(unsigned index, unsigned firstSpan) {
   // We split the column at |index|, taking |firstSpan| cells from the span.
-  ASSERT(m_effectiveColumns[index].span > firstSpan);
+  DCHECK_GT(m_effectiveColumns[index].span, firstSpan);
   m_effectiveColumns.insert(index, firstSpan);
   m_effectiveColumns[index + 1].span -= firstSpan;
 
   // Propagate the change in our columns representation to the sections that
   // don't need cell recalc. If they do, they will be synced up directly with
   // m_columns later.
   for (LayoutObject* child = firstChild(); child;
        child = child->nextSibling()) {
     if (!child->isTableSection())
       continue;
@@ skipping 41 matching lines @@
   for (LayoutObject* child = firstChild(); child;
        child = child->nextSibling()) {
     if (child->isLayoutTableCol())
       return toLayoutTableCol(child);
   }
 
   return nullptr;
 }
 
 void LayoutTable::updateColumnCache() const {
-  ASSERT(m_hasColElements);
-  ASSERT(m_columnLayoutObjects.isEmpty());
-  ASSERT(!m_columnLayoutObjectsValid);
+  DCHECK(m_hasColElements);
+  DCHECK(m_columnLayoutObjects.isEmpty());
+  DCHECK(!m_columnLayoutObjectsValid);
 
   for (LayoutTableCol* columnLayoutObject = firstColumn(); columnLayoutObject;
        columnLayoutObject = columnLayoutObject->nextColumn()) {
     if (columnLayoutObject->isTableColumnGroupWithColumnChildren())
       continue;
     m_columnLayoutObjects.push_back(columnLayoutObject);
   }
   m_columnLayoutObjectsValid = true;
 }
 
 LayoutTable::ColAndColGroup LayoutTable::slowColElementAtAbsoluteColumn(
     unsigned absoluteColumnIndex) const {
-  ASSERT(m_hasColElements);
+  DCHECK(m_hasColElements);
 
   if (!m_columnLayoutObjectsValid)
     updateColumnCache();
 
   unsigned columnCount = 0;
   for (unsigned i = 0; i < m_columnLayoutObjects.size(); i++) {
     LayoutTableCol* columnLayoutObject = m_columnLayoutObjects[i];
-    ASSERT(!columnLayoutObject->isTableColumnGroupWithColumnChildren());
+    DCHECK(!columnLayoutObject->isTableColumnGroupWithColumnChildren());
     unsigned span = columnLayoutObject->span();
     unsigned startCol = columnCount;
-    ASSERT(span >= 1);
+    DCHECK_GE(span, 1u);
     unsigned endCol = columnCount + span - 1;
     columnCount += span;
     if (columnCount > absoluteColumnIndex) {
       ColAndColGroup colAndColGroup;
       bool isAtStartEdge = startCol == absoluteColumnIndex;
       bool isAtEndEdge = endCol == absoluteColumnIndex;
       if (columnLayoutObject->isTableColumnGroup()) {
         colAndColGroup.colgroup = columnLayoutObject;
         colAndColGroup.adjoinsStartBorderOfColGroup = isAtStartEdge;
         colAndColGroup.adjoinsEndBorderOfColGroup = isAtEndEdge;
       } else {
         colAndColGroup.col = columnLayoutObject;
         colAndColGroup.colgroup = columnLayoutObject->enclosingColumnGroup();
         if (colAndColGroup.colgroup) {
           colAndColGroup.adjoinsStartBorderOfColGroup =
               isAtStartEdge && !colAndColGroup.col->previousSibling();
           colAndColGroup.adjoinsEndBorderOfColGroup =
               isAtEndEdge && !colAndColGroup.col->nextSibling();
         }
       }
       return colAndColGroup;
     }
   }
   return ColAndColGroup();
 }
 
 void LayoutTable::recalcSections() const {
-  ASSERT(m_needsSectionRecalc);
+  DCHECK(m_needsSectionRecalc);
 
   m_head = nullptr;
   m_foot = nullptr;
   m_firstBody = nullptr;
   m_hasColElements = false;
 
   // We need to get valid pointers to caption, head, foot and first body again
   LayoutObject* nextSibling;
   for (LayoutObject* child = firstChild(); child; child = nextSibling) {
     nextSibling = child->nextSibling();
@@ skipping 45 matching lines @@
       unsigned sectionCols = section->numEffectiveColumns();
       if (sectionCols > maxCols)
         maxCols = sectionCols;
     }
   }
 
   m_effectiveColumns.resize(maxCols);
   m_effectiveColumnPositions.resize(maxCols + 1);
   m_noCellColspanAtLeast = calcNoCellColspanAtLeast();
 
-  ASSERT(selfNeedsLayout());
+  DCHECK(selfNeedsLayout());
 
   m_needsSectionRecalc = false;
 }
 
 int LayoutTable::calcBorderStart() const {
   if (!collapseBorders())
     return LayoutBlock::borderStart().toInt();
 
   // Determined by the first cell of the first row. See the CSS 2.1 spec,
   // section 17.6.2.
@@ skipping 305 matching lines @@
   unsigned r = cell->rowIndex();
   LayoutTableSection* section = nullptr;
   unsigned rAbove = 0;
   if (r > 0) {
     // cell is not in the first row, so use the above row in its own section
     section = cell->section();
     rAbove = r - 1;
   } else {
     section = sectionAbove(cell->section(), SkipEmptySections);
     if (section) {
-      ASSERT(section->numRows());
+      DCHECK(section->numRows());
       rAbove = section->numRows() - 1;
     }
   }
 
   // Look up the cell in the section's grid, which requires effective col index
   if (section) {
     unsigned effCol =
         absoluteColumnToEffectiveColumn(cell->absoluteColumnIndex());
     return section->primaryCellAt(rAbove, effCol);
   }
@@ skipping 44 matching lines @@
 
   unsigned effCol = absoluteColumnToEffectiveColumn(
       cell->absoluteColumnIndex() + cell->colSpan());
   return cell->section()->primaryCellAt(cell->rowIndex(), effCol);
 }
 
 int LayoutTable::baselinePosition(FontBaseline baselineType,
                                   bool firstLine,
                                   LineDirectionMode direction,
                                   LinePositionMode linePositionMode) const {
-  ASSERT(linePositionMode == PositionOnContainingLine);
+  DCHECK_EQ(linePositionMode, PositionOnContainingLine);
   int baseline = firstLineBoxBaseline();
   if (baseline != -1) {
     if (isInline())
       return beforeMarginInLineDirection(direction) + baseline;
     return baseline;
   }
 
   return LayoutBox::baselinePosition(baselineType, firstLine, direction,
                                      linePositionMode);
 }
@@ skipping 107 matching lines @@
           parent->styleRef(),
           parent->isLayoutInline() ? EDisplay::kInlineTable : EDisplay::kTable);
   LayoutTable* newTable = new LayoutTable(nullptr);
   newTable->setDocumentForAnonymous(&parent->document());
   newTable->setStyle(std::move(newStyle));
   return newTable;
 }
 
 const BorderValue& LayoutTable::tableStartBorderAdjoiningCell(
     const LayoutTableCell* cell) const {
-  ASSERT(cell->isFirstOrLastCellInRow());
+#if DCHECK_IS_ON()
+  DCHECK(cell->isFirstOrLastCellInRow());
+#endif
   if (hasSameDirectionAs(cell->row()))
     return style()->borderStart();
 
   return style()->borderEnd();
 }
 
 const BorderValue& LayoutTable::tableEndBorderAdjoiningCell(
     const LayoutTableCell* cell) const {
-  ASSERT(cell->isFirstOrLastCellInRow());
+#if DCHECK_IS_ON()
+  DCHECK(cell->isFirstOrLastCellInRow());
+#endif
   if (hasSameDirectionAs(cell->row()))
     return style()->borderEnd();
 
   return style()->borderStart();
 }
 
 void LayoutTable::ensureIsReadyForPaintInvalidation() {
   LayoutBlock::ensureIsReadyForPaintInvalidation();
   recalcCollapsedBordersIfNeeded();
 }
@@ skipping 34 matching lines @@
 }
 
 LayoutUnit LayoutTable::paddingRight() const {
   if (collapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::paddingRight();
 }
 
 }  // namespace blink