Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 37 matching lines @@
       : positionOffset(position), distributionOffset(distribution) {}
 
   bool isValid() { return positionOffset >= 0 && distributionOffset >= 0; }
 
   LayoutUnit positionOffset = LayoutUnit(-1);
   LayoutUnit distributionOffset = LayoutUnit(-1);
 };
 
 LayoutGrid::LayoutGrid(Element* element)
     : LayoutBlock(element), m_grid(this), m_trackSizingAlgorithm(this, m_grid) {
-  ASSERT(!childrenInline());
+  DCHECK(!childrenInline());
   if (!isAnonymous())
     UseCounter::count(document(), UseCounter::CSSGridLayout);
 }
 
 LayoutGrid::~LayoutGrid() {}
 
 LayoutGrid* LayoutGrid::createAnonymous(Document* document) {
   LayoutGrid* layoutGrid = new LayoutGrid(nullptr);
   layoutGrid->setDocumentForAnonymous(document);
   return layoutGrid;
@@ skipping 108 matching lines @@
   // all the cases with orthogonal flows require this extra cycle; we need a
   // more specific condition to detect whether child's min-content contribution
   // has changed or not.
   if (m_grid.hasAnyOrthogonalGridItem()) {
     computeTrackSizesForDefiniteSize(ForColumns, availableSpaceForColumns);
     computeTrackSizesForDefiniteSize(ForRows, availableSpaceForRows);
   }
 }
 
 void LayoutGrid::layoutBlock(bool relayoutChildren) {
-  ASSERT(needsLayout());
+  DCHECK(needsLayout());
 
   // We cannot perform a simplifiedLayout() on a dirty grid that
   // has positioned items to be laid out.
   if (!relayoutChildren &&
       (!m_grid.needsItemsPlacement() || !posChildNeedsLayout()) &&
       simplifiedLayout())
     return;
 
   SubtreeLayoutScope layoutScope(*this);
 
@@ skipping 496 matching lines @@
 
   grid.setNeedsItemsPlacement(false);
 
 #if DCHECK_IS_ON()
   for (LayoutBox* child = grid.orderIterator().first(); child;
        child = grid.orderIterator().next()) {
     if (child->isOutOfFlowPositioned())
       continue;
 
     GridArea area = grid.gridItemArea(*child);
-    ASSERT(area.rows.isTranslatedDefinite() &&
-           area.columns.isTranslatedDefinite());
+    DCHECK(area.rows.isTranslatedDefinite());
+    DCHECK(area.columns.isTranslatedDefinite());
   }
 #endif
 }
 
 void LayoutGrid::populateExplicitGridAndOrderIterator(Grid& grid) const {
   OrderIteratorPopulator populator(grid.orderIterator());
   int smallestRowStart = 0;
   int smallestColumnStart = 0;
 
   size_t autoRepeatRows = grid.autoRepeatTracks(ForRows);
@@ skipping 81 matching lines @@
   // auto-placed item's position inserted on that track. This is needed to
   // implement "sparse" packing for items locked to a given track.
   // See http://dev.w3.org/csswg/css-grid/#auto-placement-algo
   HashMap<unsigned, unsigned, DefaultHash<unsigned>::Hash,
           WTF::UnsignedWithZeroKeyHashTraits<unsigned>>
       minorAxisCursors;
 
   for (const auto& autoGridItem : autoGridItems) {
     GridSpan majorAxisPositions =
         grid.gridItemSpan(*autoGridItem, autoPlacementMajorAxisDirection());
-    ASSERT(majorAxisPositions.isTranslatedDefinite());
+    DCHECK(majorAxisPositions.isTranslatedDefinite());
     DCHECK(!grid.gridItemSpan(*autoGridItem, autoPlacementMinorAxisDirection())
                 .isTranslatedDefinite());
     size_t minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
         *style(), *autoGridItem, autoPlacementMinorAxisDirection());
     unsigned majorAxisInitialPosition = majorAxisPositions.startLine();
 
     GridIterator iterator(
         grid, autoPlacementMajorAxisDirection(), majorAxisPositions.startLine(),
         isGridAutoFlowDense ? 0
                             : minorAxisCursors.at(majorAxisInitialPosition));
@@ skipping 273 matching lines @@
 
     child->layoutIfNeeded();
 
     // We need pending layouts to be done in order to compute auto-margins
     // properly.
     updateAutoMarginsInColumnAxisIfNeeded(*child);
     updateAutoMarginsInRowAxisIfNeeded(*child);
 
     const GridArea& area = m_grid.gridItemArea(*child);
 #if DCHECK_IS_ON()
-    DCHECK(area.columns.startLine() <
-           m_trackSizingAlgorithm.tracks(ForColumns).size());
-    DCHECK(area.rows.startLine() <
-           m_trackSizingAlgorithm.tracks(ForRows).size());
+    DCHECK_LT(area.columns.startLine(),
+              m_trackSizingAlgorithm.tracks(ForColumns).size());
+    DCHECK_LT(area.rows.startLine(),
+              m_trackSizingAlgorithm.tracks(ForRows).size());
 #endif
     child->setLogicalLocation(findChildLogicalPosition(*child));
 
     // Keep track of children overflowing their grid area as we might need to
     // paint them even if the grid-area is not visible. Using physical
     // dimensions for simplicity, so we can forget about orthogonalty.
     LayoutUnit childGridAreaHeight =
         isHorizontalWritingMode() ? overrideContainingBlockContentLogicalHeight
                                   : overrideContainingBlockContentLogicalWidth;
     LayoutUnit childGridAreaWidth =
         isHorizontalWritingMode() ? overrideContainingBlockContentLogicalWidth
                                   : overrideContainingBlockContentLogicalHeight;
     LayoutRect gridAreaRect(
         gridAreaLogicalPosition(area),
         LayoutSize(childGridAreaWidth, childGridAreaHeight));
     if (!gridAreaRect.contains(child->frameRect()))
       m_gridItemsOverflowingGridArea.push_back(child);
   }
 }
 
 void LayoutGrid::prepareChildForPositionedLayout(LayoutBox& child) {
-  ASSERT(child.isOutOfFlowPositioned());
+  DCHECK(child.isOutOfFlowPositioned());
   child.containingBlock()->insertPositionedObject(&child);
 
   PaintLayer* childLayer = child.layer();
   childLayer->setStaticInlinePosition(LayoutUnit(borderStart()));
   childLayer->setStaticBlockPosition(LayoutUnit(borderBefore()));
 }
 
 void LayoutGrid::layoutPositionedObjects(bool relayoutChildren,
                                          PositionedLayoutBehavior info) {
   TrackedLayoutBoxListHashSet* positionedDescendants = positionedObjects();
@@ skipping 28 matching lines @@
 
     layoutPositionedObject(child, relayoutChildren, info);
   }
 }
 
 void LayoutGrid::offsetAndBreadthForPositionedChild(
     const LayoutBox& child,
     GridTrackSizingDirection direction,
     LayoutUnit& offset,
     LayoutUnit& breadth) {
-  ASSERT(!isOrthogonalChild(child));
+  DCHECK(!isOrthogonalChild(child));
   bool isForColumns = direction == ForColumns;
 
   GridSpan positions = GridPositionsResolver::resolveGridPositionsFromStyle(
       *style(), child, direction, autoRepeatCountForDirection(direction));
   if (positions.isIndefinite()) {
     offset = LayoutUnit();
     breadth = isForColumns ? clientLogicalWidth() : clientLogicalHeight();
     return;
   }
 
@@ skipping 322 matching lines @@
     return child.styleRef().marginLeft().isAuto() ||
            child.styleRef().marginRight().isAuto();
   return child.styleRef().marginTop().isAuto() ||
          child.styleRef().marginBottom().isAuto();
 }
 
 // TODO(lajava): This logic is shared by LayoutFlexibleBox, so it should be
 // moved to LayoutBox.
 DISABLE_CFI_PERF
 void LayoutGrid::updateAutoMarginsInRowAxisIfNeeded(LayoutBox& child) {
-  ASSERT(!child.isOutOfFlowPositioned());
+  DCHECK(!child.isOutOfFlowPositioned());
 
   LayoutUnit availableAlignmentSpace =
       child.overrideContainingBlockContentLogicalWidth() -
       child.logicalWidth() - child.marginLogicalWidth();
   if (availableAlignmentSpace <= 0)
     return;
 
   Length marginStart = child.style()->marginStartUsing(style());
   Length marginEnd = child.style()->marginEndUsing(style());
   if (marginStart.isAuto() && marginEnd.isAuto()) {
     child.setMarginStart(availableAlignmentSpace / 2, style());
     child.setMarginEnd(availableAlignmentSpace / 2, style());
   } else if (marginStart.isAuto()) {
     child.setMarginStart(availableAlignmentSpace, style());
   } else if (marginEnd.isAuto()) {
     child.setMarginEnd(availableAlignmentSpace, style());
   }
 }
 
 // TODO(lajava): This logic is shared by LayoutFlexibleBox, so it should be
 // moved to LayoutBox.
 DISABLE_CFI_PERF
 void LayoutGrid::updateAutoMarginsInColumnAxisIfNeeded(LayoutBox& child) {
-  ASSERT(!child.isOutOfFlowPositioned());
+  DCHECK(!child.isOutOfFlowPositioned());
 
   LayoutUnit availableAlignmentSpace =
       child.overrideContainingBlockContentLogicalHeight() -
       child.logicalHeight() - child.marginLogicalHeight();
   if (availableAlignmentSpace <= 0)
     return;
 
   Length marginBefore = child.style()->marginBeforeUsing(style());
   Length marginAfter = child.style()->marginAfterUsing(style());
   if (marginBefore.isAuto() && marginAfter.isAuto()) {
@@ skipping 478 matching lines @@
       return {LayoutUnit(), LayoutUnit()};
     case ContentPositionNormal:
       break;
   }
 
   NOTREACHED();
   return {LayoutUnit(), LayoutUnit()};
 }
 
 LayoutUnit LayoutGrid::translateRTLCoordinate(LayoutUnit coordinate) const {
-  ASSERT(!styleRef().isLeftToRightDirection());
+  DCHECK(!styleRef().isLeftToRightDirection());
 
   LayoutUnit alignmentOffset = m_columnPositions[0];
   LayoutUnit rightGridEdgePosition =
       m_columnPositions[m_columnPositions.size() - 1];
   return rightGridEdgePosition + alignmentOffset - coordinate;
 }
 
 LayoutPoint LayoutGrid::findChildLogicalPosition(const LayoutBox& child) const {
   LayoutUnit columnAxisOffset = columnAxisOffsetForChild(child);
   LayoutUnit rowAxisOffset = rowAxisOffsetForChild(child);
@@ skipping 51 matching lines @@
   if (direction == ForRows)
     return grid.numTracks(ForRows);
 
   return grid.numTracks(ForRows)
              ? grid.numTracks(ForColumns)
              : GridPositionsResolver::explicitGridColumnCount(
                    styleRef(), grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink