Replace ENABLE(ASSERT) with DCHECK_IS_ON().

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 87 matching lines @@
 
 size_t LayoutGrid::Grid::gridItemPaintOrder(const LayoutBox& item) const {
   return m_gridItemsIndexesMap.get(&item);
 }
 
 void LayoutGrid::Grid::setGridItemPaintOrder(const LayoutBox& item,
                                              size_t order) {
   m_gridItemsIndexesMap.set(&item, order);
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool LayoutGrid::Grid::hasAnyGridItemPaintOrder() const {
   return !m_gridItemsIndexesMap.isEmpty();
 }
 #endif
 
 void LayoutGrid::Grid::setAutoRepeatTracks(size_t autoRepeatRows,
                                            size_t autoRepeatColumns) {
   m_autoRepeatRows = autoRepeatRows;
   m_autoRepeatColumns = autoRepeatColumns;
 }
@@ skipping 710 matching lines @@
 
   size_t numberOfTracks = direction == ForColumns
                               ? sizingData.columnTracks.size()
                               : sizingData.rowTracks.size();
   LayoutUnit totalGuttersSize =
       guttersSize(sizingData.grid(), direction, 0, numberOfTracks,
                   sizingData.sizingOperation);
   minIntrinsicSize += totalGuttersSize;
   maxIntrinsicSize += totalGuttersSize;
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   DCHECK(tracksAreWiderThanMinTrackBreadth(direction, sizingData));
 #endif
 }
 
 LayoutUnit LayoutGrid::computeIntrinsicLogicalContentHeightUsing(
     const Length& logicalHeightLength,
     LayoutUnit intrinsicContentHeight,
     LayoutUnit borderAndPadding) const {
   if (logicalHeightLength.isMinContent())
     return m_minContentHeight;
@@ skipping 1065 matching lines @@
     }
   }
 
   for (auto* track : tracks)
     track->setPlannedSize(
         track->plannedSize() == infinity
             ? track->sizeDuringDistribution()
             : std::max(track->plannedSize(), track->sizeDuringDistribution()));
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool LayoutGrid::tracksAreWiderThanMinTrackBreadth(
     GridTrackSizingDirection direction,
     GridSizingData& sizingData) const {
   const Vector<GridTrack>& tracks = (direction == ForColumns)
                                         ? sizingData.columnTracks
                                         : sizingData.rowTracks;
   LayoutUnit maxSize = sizingData.availableSpace().clampNegativeToZero();
   for (size_t i = 0; i < tracks.size(); ++i) {
     GridTrackSize trackSize = gridTrackSize(direction, i, sizingData);
     if (computeUsedBreadthOfMinLength(trackSize, maxSize) >
@@ skipping 157 matching lines @@
   }
 
   if (!grid.needsItemsPlacement())
     return;
 
   DCHECK(!grid.hasGridItems());
   populateExplicitGridAndOrderIterator(grid);
 
   Vector<LayoutBox*> autoMajorAxisAutoGridItems;
   Vector<LayoutBox*> specifiedMajorAxisAutoGridItems;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   DCHECK(!grid.hasAnyGridItemPaintOrder());
 #endif
   DCHECK(!grid.hasAnyOrthogonalGridItem());
   bool hasAnyOrthogonalGridItem = false;
   size_t childIndex = 0;
   for (LayoutBox* child = grid.orderIterator().first(); child;
        child = grid.orderIterator().next()) {
     if (child->isOutOfFlowPositioned())
       continue;
 
@@ skipping 15 matching lines @@
       if (majorAxisPositions.isIndefinite())
         autoMajorAxisAutoGridItems.push_back(child);
       else
         specifiedMajorAxisAutoGridItems.push_back(child);
       continue;
     }
     grid.insert(*child, area);
   }
   grid.setHasAnyOrthogonalGridItem(hasAnyOrthogonalGridItem);
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   if (grid.hasGridItems()) {
     DCHECK_GE(grid.numTracks(ForRows),
               GridPositionsResolver::explicitGridRowCount(
                   *style(), grid.autoRepeatTracks(ForRows)));
     DCHECK_GE(grid.numTracks(ForColumns),
               GridPositionsResolver::explicitGridColumnCount(
                   *style(), grid.autoRepeatTracks(ForColumns)));
   }
 #endif
 
   placeSpecifiedMajorAxisItemsOnGrid(grid, specifiedMajorAxisAutoGridItems);
   placeAutoMajorAxisItemsOnGrid(grid, autoMajorAxisAutoGridItems);
 
   // Compute collapsable tracks for auto-fit.
   grid.setAutoRepeatEmptyColumns(
       computeEmptyTracksForAutoRepeat(grid, ForColumns));
   grid.setAutoRepeatEmptyRows(computeEmptyTracksForAutoRepeat(grid, ForRows));
 
   grid.setNeedsItemsPlacement(false);
 
-#if ENABLE(ASSERT)
+#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());
   }
 #endif
@@ skipping 386 matching lines @@
     applyStretchAlignmentToChildIfNeeded(*child);
 
     child->layoutIfNeeded();
 
     // We need pending layouts to be done in order to compute auto-margins
     // properly.
     updateAutoMarginsInColumnAxisIfNeeded(*child);
     updateAutoMarginsInRowAxisIfNeeded(*child);
 
     const GridArea& area = sizingData.grid().gridItemArea(*child);
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     ASSERT(area.columns.startLine() < sizingData.columnTracks.size());
     ASSERT(area.rows.startLine() < sizingData.rowTracks.size());
 #endif
     child->setLogicalLocation(findChildLogicalPosition(*child, sizingData));
 
     // 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
@@ skipping 1040 matching lines @@
   if (direction == ForRows)
     return grid.numTracks(ForRows);
 
   return grid.numTracks(ForRows)
              ? grid.numTracks(ForColumns)
              : GridPositionsResolver::explicitGridColumnCount(
                    styleRef(), grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink