Replace ASSERT and ASSERT_NOT_REACHED in core/style/

third_party/WebKit/Source/core/style/GridPositionsResolver.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "GridPositionsResolver.h"
 
 #include "core/layout/LayoutBox.h"
 #include "core/style/GridArea.h"
 #include <algorithm>
 
@@ skipping 186 matching lines @@
     finalPosition.setSpanPosition(1, nullAtom);
   if (finalPosition.isAuto() && initialPosition.isSpan() &&
       !initialPosition.namedGridLine().isNull())
     initialPosition.setSpanPosition(1, nullAtom);
 }
 
 static size_t lookAheadForNamedGridLine(int start,
                                         size_t numberOfLines,
                                         size_t gridLastLine,
                                         NamedLineCollection& linesCollection) {
-  ASSERT(numberOfLines);
+  DCHECK(numberOfLines);
 
   // Only implicit lines on the search direction are assumed to have the given
   // name, so we can start to look from first line.
   // See: https://drafts.csswg.org/css-grid/#grid-placement-span-int
   size_t end = std::max(start, 0);
 
   if (!linesCollection.hasNamedLines()) {
     end = std::max(end, gridLastLine + 1);
     return end + numberOfLines - 1;
   }
 
   for (; numberOfLines; ++end) {
     if (end > gridLastLine || linesCollection.contains(end))
       numberOfLines--;
   }
 
-  ASSERT(end);
+  DCHECK(end);
   return end - 1;
 }
 
 static int lookBackForNamedGridLine(int end,
                                     size_t numberOfLines,
                                     int gridLastLine,
                                     NamedLineCollection& linesCollection) {
-  ASSERT(numberOfLines);
+  DCHECK(numberOfLines);
 
   // Only implicit lines on the search direction are assumed to have the given
   // name, so we can start to look from last line.
   // See: https://drafts.csswg.org/css-grid/#grid-placement-span-int
   int start = std::min(end, gridLastLine);
 
   if (!linesCollection.hasNamedLines()) {
     start = std::min(start, -1);
     return start - numberOfLines + 1;
   }
@@ skipping 55 matching lines @@
              : GridPositionsResolver::explicitGridRowCount(
                    gridContainerStyle, autoRepeatTracksCount);
 }
 
 static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(
     const ComputedStyle& gridContainerStyle,
     int oppositeLine,
     const GridPosition& position,
     size_t autoRepeatTracksCount,
     GridPositionSide side) {
-  ASSERT(position.isSpan());
-  ASSERT(!position.namedGridLine().isNull());
+  DCHECK(position.isSpan());
+  DCHECK(!position.namedGridLine().isNull());
   // Negative positions are not allowed per the specification and should have
   // been handled during parsing.
-  ASSERT(position.spanPosition() > 0);
+  DCHECK_GT(position.spanPosition(), 0);
 
   size_t lastLine =
       explicitGridSizeForSide(gridContainerStyle, side, autoRepeatTracksCount);
   NamedLineCollection linesCollection(
       gridContainerStyle, position.namedGridLine(), directionFromSide(side),
       lastLine, autoRepeatTracksCount);
   return definiteGridSpanWithNamedSpanAgainstOpposite(
       oppositeLine, position, side, lastLine, linesCollection);
 }
 
@@ skipping 17 matching lines @@
     GridPositionSide side,
     size_t autoRepeatTracksCount) {
   if (position.isAuto()) {
     if (side == ColumnStartSide || side == RowStartSide)
       return GridSpan::untranslatedDefiniteGridSpan(oppositeLine - 1,
                                                     oppositeLine);
     return GridSpan::untranslatedDefiniteGridSpan(oppositeLine,
                                                   oppositeLine + 1);
   }
 
-  ASSERT(position.isSpan());
-  ASSERT(position.spanPosition() > 0);
+  DCHECK(position.isSpan());
+  DCHECK_GT(position.spanPosition(), 0);
 
   if (!position.namedGridLine().isNull()) {
     // span 2 'c' -> we need to find the appropriate grid line before / after
     // our opposite position.
     return resolveNamedGridLinePositionAgainstOppositePosition(
         gridContainerStyle, oppositeLine, position, autoRepeatTracksCount,
         side);
   }
 
   return definiteGridSpanWithSpanAgainstOpposite(oppositeLine, position, side);
 }
 
 size_t GridPositionsResolver::spanSizeForAutoPlacedItem(
     const ComputedStyle& gridContainerStyle,
     const LayoutBox& gridItem,
     GridTrackSizingDirection direction) {
   GridPosition initialPosition, finalPosition;
   initialAndFinalPositionsFromStyle(gridContainerStyle, gridItem, direction,
                                     initialPosition, finalPosition);
 
   // This method will only be used when both positions need to be resolved
   // against the opposite one.
-  ASSERT(initialPosition.shouldBeResolvedAgainstOppositePosition() &&
+  DCHECK(initialPosition.shouldBeResolvedAgainstOppositePosition() &&

[tkent, 2017/03/15 05:02:20]

Please split it to two DCHEKS.
  DCHECK(initialPosition.shouldBeResolvedAgainstOppositePosition());
  DCHECK(finalPosition.shouldBeResolvedAgainstOppositePosition());

          finalPosition.shouldBeResolvedAgainstOppositePosition());
 
   if (initialPosition.isAuto() && finalPosition.isAuto())
     return 1;
 
   GridPosition position =
       initialPosition.isSpan() ? initialPosition : finalPosition;
-  ASSERT(position.isSpan());
-  ASSERT(position.spanPosition());
+  DCHECK(position.isSpan());
+  DCHECK(position.spanPosition());
   return position.spanPosition();
 }
 
 static int resolveNamedGridLinePositionFromStyle(
     const ComputedStyle& gridContainerStyle,
     const GridPosition& position,
     GridPositionSide side,
     size_t autoRepeatTracksCount) {
-  ASSERT(!position.namedGridLine().isNull());
+  DCHECK(!position.namedGridLine().isNull());
 
   size_t lastLine =
       explicitGridSizeForSide(gridContainerStyle, side, autoRepeatTracksCount);
   NamedLineCollection linesCollection(
       gridContainerStyle, position.namedGridLine(), directionFromSide(side),
       lastLine, autoRepeatTracksCount);
 
   if (position.isPositive())
     return lookAheadForNamedGridLine(0, abs(position.integerPosition()),
                                      lastLine, linesCollection);
 
   return lookBackForNamedGridLine(lastLine, abs(position.integerPosition()),
                                   lastLine, linesCollection);
 }
 
 static int resolveGridPositionFromStyle(const ComputedStyle& gridContainerStyle,
                                         const GridPosition& position,
                                         GridPositionSide side,
                                         size_t autoRepeatTracksCount) {
   switch (position.type()) {
     case ExplicitPosition: {
-      ASSERT(position.integerPosition());
+      DCHECK(position.integerPosition());
 
       if (!position.namedGridLine().isNull())
         return resolveNamedGridLinePositionFromStyle(
             gridContainerStyle, position, side, autoRepeatTracksCount);
 
       // Handle <integer> explicit position.
       if (position.isPositive())
         return position.integerPosition() - 1;
 
       size_t resolvedPosition = abs(position.integerPosition()) - 1;
       size_t endOfTrack = explicitGridSizeForSide(gridContainerStyle, side,
                                                   autoRepeatTracksCount);
 
       return endOfTrack - resolvedPosition;
     }
     case NamedGridAreaPosition: {
       // First attempt to match the grid area's edge to a named grid area: if
       // there is a named line with the name ''<custom-ident>-start (for
       // grid-*-start) / <custom-ident>-end'' (for grid-*-end), contributes the
       // first such line to the grid item's placement.
       String namedGridLine = position.namedGridLine();
-      ASSERT(!position.namedGridLine().isNull());
+      DCHECK(!position.namedGridLine().isNull());
 
       size_t lastLine = explicitGridSizeForSide(gridContainerStyle, side,
                                                 autoRepeatTracksCount);
       NamedLineCollection implicitLines(
           gridContainerStyle, implicitNamedGridLineForSide(namedGridLine, side),
           directionFromSide(side), lastLine, autoRepeatTracksCount);
       if (implicitLines.hasNamedLines())
         return implicitLines.firstPosition();
 
       // Otherwise, if there is a named line with the specified name,
       // contributes the first such line to the grid item's placement.
       NamedLineCollection explicitLines(gridContainerStyle, namedGridLine,
                                         directionFromSide(side), lastLine,
                                         autoRepeatTracksCount);
       if (explicitLines.hasNamedLines())
         return explicitLines.firstPosition();
 
-      ASSERT(!NamedLineCollection::isValidNamedLineOrArea(
+      DCHECK(!NamedLineCollection::isValidNamedLineOrArea(
           namedGridLine, gridContainerStyle, side));
       // If none of the above works specs mandate to assume that all the lines
       // in the implicit grid have this name.
       return lastLine + 1;
     }
     case AutoPosition:
     case SpanPosition:
       // 'auto' and span depend on the opposite position for resolution (e.g.
       // grid-row: auto / 1 or grid-column: span 3 / "myHeader").
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return 0;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return 0;
 }
 
 GridSpan GridPositionsResolver::resolveGridPositionsFromStyle(
     const ComputedStyle& gridContainerStyle,
     const LayoutBox& gridItem,
     GridTrackSizingDirection direction,
     size_t autoRepeatTracksCount) {
   GridPosition initialPosition, finalPosition;
   initialAndFinalPositionsFromStyle(gridContainerStyle, gridItem, direction,
@@ skipping 37 matching lines @@
 
   if (endLine < startLine)
     std::swap(endLine, startLine);
   else if (endLine == startLine)
     endLine = startLine + 1;
 
   return GridSpan::untranslatedDefiniteGridSpan(startLine, endLine);
 }
 
 }  // namespace blink