Replace ASSERT_NOT_REACHED with NOTREACHED in core/layout/

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 420 matching lines @@
     LayoutUnit fillAvailableExtent =
         containingBlock()->availableLogicalHeight(ExcludeMarginBorderPadding);
     return std::min<LayoutUnit>(
         m_maxContentHeight, std::max(m_minContentHeight, fillAvailableExtent));
   }
 
   if (logicalHeightLength.isFillAvailable())
     return containingBlock()->availableLogicalHeight(
                ExcludeMarginBorderPadding) -
            borderAndPadding;
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return LayoutUnit();
 }
 
 static LayoutUnit overrideContainingBlockContentSizeForChild(
     const LayoutBox& child,
     GridTrackSizingDirection direction) {
   return direction == ForColumns
              ? child.overrideContainingBlockContentLogicalWidth()
              : child.overrideContainingBlockContentLogicalHeight();
 }
@@ skipping 918 matching lines @@
       // unreachable).
       return offset.clampNegativeToZero();
     case OverflowAlignmentUnsafe:
     case OverflowAlignmentDefault:
       // If we overflow our alignment container and overflow is 'true'
       // (default), we ignore the overflow and just return the value regardless
       // (which may cause data loss as we overflow the 'start' edge).
       return offset;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return LayoutUnit();
 }
 
 // FIXME: This logic is shared by LayoutFlexibleBox, so it should be moved to
 // LayoutBox.
 LayoutUnit LayoutGrid::marginLogicalHeightForChild(
     const LayoutBox& child) const {
   return isHorizontalWritingMode() ? child.marginHeight() : child.marginWidth();
 }
 
@@ skipping 342 matching lines @@
     case ItemPositionBaseline:
     case ItemPositionLastBaseline:
       // FIXME: These two require implementing Baseline Alignment. For now, we
       // always 'start' align the child. crbug.com/234191
       return GridAxisStart;
     case ItemPositionAuto:
     case ItemPositionNormal:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return GridAxisStart;
 }
 
 GridAxisPosition LayoutGrid::rowAxisPositionForChild(
     const LayoutBox& child) const {
   bool hasSameDirection =
       child.styleRef().direction() == styleRef().direction();
   bool gridIsLTR = styleRef().isLeftToRightDirection();
 
   switch (justifySelfForChild(child).position()) {
@@ skipping 58 matching lines @@
     case ItemPositionBaseline:
     case ItemPositionLastBaseline:
       // FIXME: These two require implementing Baseline Alignment. For now, we
       // always 'start' align the child. crbug.com/234191
       return GridAxisStart;
     case ItemPositionAuto:
     case ItemPositionNormal:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return GridAxisStart;
 }
 
 LayoutUnit LayoutGrid::columnAxisOffsetForChild(const LayoutBox& child) const {
   const GridSpan& rowsSpan =
       m_trackSizingAlgorithm.grid().gridItemSpan(child, ForRows);
   size_t childStartLine = rowsSpan.startLine();
   LayoutUnit startOfRow = m_rowPositions[childStartLine];
   LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
   if (hasAutoMarginsInColumnAxis(child))
@@ skipping 21 matching lines @@
               : child.logicalHeight() + child.marginLogicalHeight();
       OverflowAlignment overflow = alignSelfForChild(child).overflow();
       LayoutUnit offsetFromStartPosition = computeOverflowAlignmentOffset(
           overflow, endOfRow - startOfRow, columnAxisChildSize);
       return startPosition + (axisPosition == GridAxisEnd
                                   ? offsetFromStartPosition
                                   : offsetFromStartPosition / 2);
     }
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return LayoutUnit();
 }
 
 LayoutUnit LayoutGrid::rowAxisOffsetForChild(const LayoutBox& child) const {
   const GridSpan& columnsSpan =
       m_trackSizingAlgorithm.grid().gridItemSpan(child, ForColumns);
   size_t childStartLine = columnsSpan.startLine();
   LayoutUnit startOfColumn = m_columnPositions[childStartLine];
   LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
   if (hasAutoMarginsInRowAxis(child))
@@ skipping 21 matching lines @@
               : child.logicalWidth() + child.marginLogicalWidth();
       OverflowAlignment overflow = justifySelfForChild(child).overflow();
       LayoutUnit offsetFromStartPosition = computeOverflowAlignmentOffset(
           overflow, endOfColumn - startOfColumn, rowAxisChildSize);
       return startPosition + (axisPosition == GridAxisEnd
                                   ? offsetFromStartPosition
                                   : offsetFromStartPosition / 2);
     }
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return LayoutUnit();
 }
 
 ContentPosition static resolveContentDistributionFallback(
     ContentDistributionType distribution) {
   switch (distribution) {
     case ContentDistributionSpaceBetween:
       return ContentPositionStart;
     case ContentDistributionSpaceAround:
       return ContentPositionCenter;
     case ContentDistributionSpaceEvenly:
       return ContentPositionCenter;
     case ContentDistributionStretch:
       return ContentPositionStart;
     case ContentDistributionDefault:
       return ContentPositionNormal;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ContentPositionNormal;
 }
 
 static ContentAlignmentData contentDistributionOffset(
     const LayoutUnit& availableFreeSpace,
     ContentPosition& fallbackPosition,
     ContentDistributionType distribution,
     unsigned numberOfGridTracks) {
   if (distribution != ContentDistributionDefault &&
       fallbackPosition == ContentPositionNormal)
@@ skipping 14 matching lines @@
       distributionOffset = availableFreeSpace / numberOfGridTracks;
       return {distributionOffset / 2, distributionOffset};
     case ContentDistributionSpaceEvenly:
       distributionOffset = availableFreeSpace / (numberOfGridTracks + 1);
       return {distributionOffset, distributionOffset};
     case ContentDistributionStretch:
     case ContentDistributionDefault:
       return {};
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return {};
 }
 
 ContentAlignmentData LayoutGrid::computeContentPositionAndDistributionOffset(
     GridTrackSizingDirection direction,
     const LayoutUnit& availableFreeSpace,
     unsigned numberOfGridTracks) const {
   bool isRowAxis = direction == ForColumns;
   ContentPosition position = isRowAxis
                                  ? styleRef().resolvedJustifyContentPosition(
@@ skipping 55 matching lines @@
       // always 'start' align the child. crbug.com/234191
       if (isRowAxis)
         return {styleRef().isLeftToRightDirection() ? LayoutUnit()
                                                     : availableFreeSpace,
                 LayoutUnit()};
       return {LayoutUnit(), LayoutUnit()};
     case ContentPositionNormal:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return {LayoutUnit(), LayoutUnit()};
 }
 
 LayoutUnit LayoutGrid::translateRTLCoordinate(LayoutUnit coordinate) const {
   ASSERT(!styleRef().isLeftToRightDirection());
 
   LayoutUnit alignmentOffset = m_columnPositions[0];
   LayoutUnit rightGridEdgePosition =
       m_columnPositions[m_columnPositions.size() - 1];
   return rightGridEdgePosition + alignmentOffset - coordinate;
@@ skipping 56 matching lines @@
   if (direction == ForRows)
     return grid.numTracks(ForRows);
 
   return grid.numTracks(ForRows)
              ? grid.numTracks(ForColumns)
              : GridPositionsResolver::explicitGridColumnCount(
                    styleRef(), grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink