Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/css/

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 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 "core/css/parser/CSSPropertyParser.h"
 
 #include <memory>
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSBorderImage.h"
@@ skipping 54 matching lines @@
     HeapVector<CSSProperty, 256>* parsedProperties)
     : m_range(range), m_context(context), m_parsedProperties(parsedProperties) {
   m_range.consumeWhitespace();
 }
 
 void CSSPropertyParser::addProperty(CSSPropertyID property,
                                     CSSPropertyID currentShorthand,
                                     const CSSValue& value,
                                     bool important,
                                     bool implicit) {
-  ASSERT(!isPropertyAlias(property));
+  DCHECK(!isPropertyAlias(property));
 
   int shorthandIndex = 0;
   bool setFromShorthand = false;
 
   if (currentShorthand) {
     Vector<StylePropertyShorthand, 4> shorthands;
     getMatchingShorthandsForLonghand(property, &shorthands);
     setFromShorthand = true;
     if (shorthands.size() > 1)
       shorthandIndex =
           indexOfShorthandForLonghand(currentShorthand, shorthands);
   }
 
   m_parsedProperties->push_back(CSSProperty(
       property, value, important, setFromShorthand, shorthandIndex, implicit));
 }
 
 void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID property,
                                                     const CSSValue& value,
                                                     bool important) {
   const StylePropertyShorthand& shorthand = shorthandForProperty(property);
   unsigned shorthandLength = shorthand.length();
-  ASSERT(shorthandLength);
+  DCHECK(shorthandLength);
   const CSSPropertyID* longhands = shorthand.properties();
   for (unsigned i = 0; i < shorthandLength; ++i)
     addProperty(longhands[i], property, value, important);
 }
 
 bool CSSPropertyParser::parseValue(
     CSSPropertyID unresolvedProperty,
     bool important,
     const CSSParserTokenRange& range,
     const CSSParserContext* context,
@@ skipping 249 matching lines @@
   if (unresolvedProperty != CSSPropertyInvalid &&
       unresolvedProperty != CSSPropertyVariable) {
     DCHECK(CSSPropertyMetadata::isEnabledProperty(unresolvedProperty));
     range.consumeIncludingWhitespace();
     return CSSCustomIdentValue::create(unresolvedProperty);
   }
   return consumeCustomIdent(range);
 }
 
 static CSSValue* consumeSteps(CSSParserTokenRange& range) {
-  ASSERT(range.peek().functionId() == CSSValueSteps);
+  DCHECK_EQ(range.peek().functionId(), CSSValueSteps);
   CSSParserTokenRange rangeCopy = range;
   CSSParserTokenRange args = consumeFunction(rangeCopy);
 
   CSSPrimitiveValue* steps = consumePositiveInteger(args);
   if (!steps)
     return nullptr;
 
   StepsTimingFunction::StepPosition position =
       StepsTimingFunction::StepPosition::END;
   if (consumeCommaIncludingWhitespace(args)) {
@@ skipping 15 matching lines @@
   }
 
   if (!args.atEnd())
     return nullptr;
 
   range = rangeCopy;
   return CSSStepsTimingFunctionValue::create(steps->getIntValue(), position);
 }
 
 static CSSValue* consumeCubicBezier(CSSParserTokenRange& range) {
-  ASSERT(range.peek().functionId() == CSSValueCubicBezier);
+  DCHECK_EQ(range.peek().functionId(), CSSValueCubicBezier);
   CSSParserTokenRange rangeCopy = range;
   CSSParserTokenRange args = consumeFunction(rangeCopy);
 
   double x1, y1, x2, y2;
   if (consumeNumberRaw(args, x1) && x1 >= 0 && x1 <= 1 &&
       consumeCommaIncludingWhitespace(args) && consumeNumberRaw(args, y1) &&
       consumeCommaIncludingWhitespace(args) && consumeNumberRaw(args, x2) &&
       x2 >= 0 && x2 <= 1 && consumeCommaIncludingWhitespace(args) &&
       consumeNumberRaw(args, y2) && args.atEnd()) {
     range = rangeCopy;
@@ skipping 41 matching lines @@
     case CSSPropertyAnimationName:
       return consumeAnimationName(range, context, useLegacyParsing);
     case CSSPropertyAnimationPlayState:
       return consumeIdent<CSSValueRunning, CSSValuePaused>(range);
     case CSSPropertyTransitionProperty:
       return consumeTransitionProperty(range);
     case CSSPropertyAnimationTimingFunction:
     case CSSPropertyTransitionTimingFunction:
       return consumeAnimationTimingFunction(range);
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return nullptr;
   }
 }
 
 static bool isValidAnimationPropertyList(CSSPropertyID property,
                                          const CSSValueList& valueList) {
   if (property != CSSPropertyTransitionProperty || valueList.length() < 2)
     return true;
   for (auto& value : valueList) {
     if (value->isIdentifierValue() &&
@@ skipping 11 matching lines @@
   CSSValueList* list = CSSValueList::createCommaSeparated();
   do {
     CSSValue* value =
         consumeAnimationValue(property, range, context, useLegacyParsing);
     if (!value)
       return nullptr;
     list->append(*value);
   } while (consumeCommaIncludingWhitespace(range));
   if (!isValidAnimationPropertyList(property, *list))
     return nullptr;
-  ASSERT(list->length());
+  DCHECK(list->length());
   return list;
 }
 
 bool CSSPropertyParser::consumeAnimationShorthand(
     const StylePropertyShorthand& shorthand,
     bool useLegacyParsing,
     bool important) {
   const unsigned longhandCount = shorthand.length();
   CSSValueList* longhands[8];
-  ASSERT(longhandCount <= 8);
+  DCHECK_LE(longhandCount, 8u);
   for (size_t i = 0; i < longhandCount; ++i)
     longhands[i] = CSSValueList::createCommaSeparated();
 
   do {
     bool parsedLonghand[8] = {false};
     do {
       bool foundProperty = false;
       for (size_t i = 0; i < longhandCount; ++i) {
         if (parsedLonghand[i])
           continue;
@@ skipping 606 matching lines @@
         continue;
     }
     if (!repeat) {
       repeat = consumeBorderImageRepeat(range);
       if (repeat)
         continue;
     }
     if (!slice) {
       slice = consumeBorderImageSlice(property, range);
       if (slice) {
-        ASSERT(!width && !outset);
+        DCHECK(!width);
+        DCHECK(!outset);
         if (consumeSlashIncludingWhitespace(range)) {
           width = consumeBorderImageWidth(range);
           if (consumeSlashIncludingWhitespace(range)) {
             outset = consumeBorderImageOutset(range);
             if (!outset)
               return false;
           } else if (!width) {
             return false;
           }
         }
@@ skipping 64 matching lines @@
 static CSSValue* consumeBackgroundBox(CSSParserTokenRange& range) {
   return consumeIdent<CSSValueBorderBox, CSSValuePaddingBox,
                       CSSValueContentBox>(range);
 }
 
 static CSSValue* consumeBackgroundComposite(CSSParserTokenRange& range) {
   return consumeIdentRange(range, CSSValueClear, CSSValuePlusLighter);
 }
 
 static CSSValue* consumeMaskSourceType(CSSParserTokenRange& range) {
-  ASSERT(RuntimeEnabledFeatures::cssMaskSourceTypeEnabled());
+  DCHECK(RuntimeEnabledFeatures::cssMaskSourceTypeEnabled());
   return consumeIdent<CSSValueAuto, CSSValueAlpha, CSSValueLuminance>(range);
 }
 
 static CSSValue* consumePrefixedBackgroundBox(CSSPropertyID property,
                                               CSSParserTokenRange& range,
                                               const CSSParserContext* context) {
   // The values 'border', 'padding' and 'content' are deprecated and do not
   // apply to the version of the property that has the -webkit- prefix removed.
   if (CSSValue* value =
           consumeIdentRange(range, CSSValueBorder, CSSValuePaddingBox))
@@ skipping 174 matching lines @@
         CSSPrimitiveValue::UnitType::Integer);
   }
 
   CSSValueList* values = CSSValueList::createSpaceSeparated();
   if (spanValue)
     values->append(*spanValue);
   if (numericValue)
     values->append(*numericValue);
   if (gridLineName)
     values->append(*gridLineName);
-  ASSERT(values->length());
+  DCHECK(values->length());
   return values;
 }
 
 static bool isGridBreadthFixedSized(const CSSValue& value) {
   if (value.isIdentifierValue()) {
     CSSValueID valueID = toCSSIdentifierValue(value).getValueID();
     return !(valueID == CSSValueMinContent || valueID == CSSValueMaxContent ||
              valueID == CSSValueAuto);
   }
 
@@ skipping 14 matching lines @@
   if (function.functionType() == CSSValueFitContent)
     return false;
 
   const CSSValue& minValue = function.item(0);
   const CSSValue& maxValue = function.item(1);
   return isGridBreadthFixedSized(minValue) || isGridBreadthFixedSized(maxValue);
 }
 
 static Vector<String> parseGridTemplateAreasColumnNames(
     const String& gridRowNames) {
-  ASSERT(!gridRowNames.isEmpty());
+  DCHECK(!gridRowNames.isEmpty());
   Vector<String> columnNames;
   // Using StringImpl to avoid checks and indirection in every call to
   // String::operator[].
   StringImpl& text = *gridRowNames.impl();
 
   StringBuilder areaName;
   for (unsigned i = 0; i < text.length(); ++i) {
     if (isCSSSpace(text[i])) {
       if (!areaName.isEmpty()) {
         columnNames.push_back(areaName.toString());
@@ skipping 286 matching lines @@
   while (range.peek().type() == StringToken) {
     if (!parseGridTemplateAreasRow(
             range.consumeIncludingWhitespace().value().toString(), gridAreaMap,
             rowCount, columnCount))
       return nullptr;
     ++rowCount;
   }
 
   if (rowCount == 0)
     return nullptr;
-  ASSERT(columnCount);
+  DCHECK(columnCount);
   return CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
 }
 
 static void countKeywordOnlyPropertyUsage(CSSPropertyID property,
                                           const CSSParserContext* context,
                                           CSSValueID valueID) {
   if (!context->isUseCounterRecordingEnabled())
     return;
   switch (property) {
     case CSSPropertyWebkitAppearance: {
@@ skipping 157 matching lines @@
       return consumeBorderWidth(m_range, m_context->mode(), unitless);
     }
     case CSSPropertyTextShadow:
     case CSSPropertyBoxShadow:
       return consumeShadow(m_range, m_context->mode(),
                            property == CSSPropertyBoxShadow);
     case CSSPropertyFilter:
     case CSSPropertyBackdropFilter:
       return consumeFilter(m_range, m_context);
     case CSSPropertyTextDecoration:
-      ASSERT(!RuntimeEnabledFeatures::css3TextDecorationsEnabled());
+      DCHECK(!RuntimeEnabledFeatures::css3TextDecorationsEnabled());
     // fallthrough
     case CSSPropertyWebkitTextDecorationsInEffect:
     case CSSPropertyTextDecorationLine:
       return consumeTextDecorationLine(m_range);
     case CSSPropertyD:
       return consumePathOrNone(m_range);
     case CSSPropertyOffsetPath:
       return consumeOffsetPath(
           m_range, m_context,
           currentShorthand == CSSPropertyMotion ||
@@ skipping 77 matching lines @@
     case CSSPropertyWebkitMaskSize:
       return consumeCommaSeparatedBackgroundComponent(unresolvedProperty,
                                                       m_range, m_context);
     case CSSPropertyWebkitMaskRepeatX:
     case CSSPropertyWebkitMaskRepeatY:
       return nullptr;
     case CSSPropertyGridColumnEnd:
     case CSSPropertyGridColumnStart:
     case CSSPropertyGridRowEnd:
     case CSSPropertyGridRowStart:
-      ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+      DCHECK(RuntimeEnabledFeatures::cssGridLayoutEnabled());
       return consumeGridLine(m_range);
     case CSSPropertyGridAutoColumns:
     case CSSPropertyGridAutoRows:
-      ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+      DCHECK(RuntimeEnabledFeatures::cssGridLayoutEnabled());
       return consumeGridTrackList(m_range, m_context->mode(), GridAuto);
     case CSSPropertyGridTemplateColumns:
     case CSSPropertyGridTemplateRows:
-      ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+      DCHECK(RuntimeEnabledFeatures::cssGridLayoutEnabled());
       return consumeGridTemplatesRowsOrColumns(m_range, m_context->mode());
     case CSSPropertyGridTemplateAreas:
-      ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+      DCHECK(RuntimeEnabledFeatures::cssGridLayoutEnabled());
       return consumeGridTemplateAreas(m_range);
     default:
       return nullptr;
   }
 }
 
 static CSSIdentifierValue* consumeFontDisplay(CSSParserTokenRange& range) {
   return consumeIdent<CSSValueAuto, CSSValueBlock, CSSValueSwap,
                       CSSValueFallback, CSSValueOptional>(range);
 }
@@ skipping 120 matching lines @@
 
   if (!parsedValue || !m_range.atEnd())
     return false;
 
   addProperty(propId, CSSPropertyInvalid, *parsedValue, false);
   return true;
 }
 
 bool CSSPropertyParser::consumeSystemFont(bool important) {
   CSSValueID systemFontID = m_range.consumeIncludingWhitespace().id();
-  ASSERT(systemFontID >= CSSValueCaption && systemFontID <= CSSValueStatusBar);
+  DCHECK_GE(systemFontID, CSSValueCaption);
+  DCHECK_LE(systemFontID, CSSValueStatusBar);
   if (!m_range.atEnd())
     return false;
 
   FontStyle fontStyle = FontStyleNormal;
   FontWeight fontWeight = FontWeightNormal;
   float fontSize = 0;
   AtomicString fontFamily;
   LayoutTheme::theme().systemFont(systemFontID, fontStyle, fontWeight, fontSize,
                                   fontFamily);
 
@@ skipping 226 matching lines @@
       if (parsedValue)
         return parsedValue;
       return consumePercent(range, ValueRangeNonNegative);
     }
     case CSSPropertyUserZoom:
       return consumeIdent<CSSValueZoom, CSSValueFixed>(range);
     case CSSPropertyOrientation:
       return consumeIdent<CSSValueAuto, CSSValuePortrait, CSSValueLandscape>(
           range);
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return nullptr;
 }
 
 bool CSSPropertyParser::parseViewportDescriptor(CSSPropertyID propId,
                                                 bool important) {
-  ASSERT(RuntimeEnabledFeatures::cssViewportEnabled() ||
+  DCHECK(RuntimeEnabledFeatures::cssViewportEnabled() ||
          isUASheetBehavior(m_context->mode()));
 
   switch (propId) {
     case CSSPropertyWidth: {
       CSSValue* minWidth = consumeSingleViewportDescriptor(
           m_range, CSSPropertyMinWidth, m_context->mode());
       if (!minWidth)
         return false;
       CSSValue* maxWidth = minWidth;
       if (!m_range.atEnd()) {
@@ skipping 203 matching lines @@
   addExpandedPropertyForValue(CSSPropertyBorderStyle, *style, important);
   addExpandedPropertyForValue(CSSPropertyBorderColor, *color, important);
   addExpandedPropertyForValue(CSSPropertyBorderImage,
                               *CSSInitialValue::create(), important);
 
   return m_range.atEnd();
 }
 
 bool CSSPropertyParser::consume4Values(const StylePropertyShorthand& shorthand,
                                        bool important) {
-  ASSERT(shorthand.length() == 4);
+  DCHECK_EQ(shorthand.length(), 4u);
   const CSSPropertyID* longhands = shorthand.properties();
   const CSSValue* top = parseSingleValue(longhands[0], shorthand.id());
   if (!top)
     return false;
 
   const CSSValue* right = parseSingleValue(longhands[1], shorthand.id());
   const CSSValue* bottom = nullptr;
   const CSSValue* left = nullptr;
   if (right) {
     bottom = parseSingleValue(longhands[2], shorthand.id());
@@ skipping 49 matching lines @@
         addProperty(CSSPropertyBorderImageSlice, CSSPropertyBorderImage,
                     slice ? *slice : *CSSInitialValue::create(), important);
         addProperty(CSSPropertyBorderImageWidth, CSSPropertyBorderImage,
                     width ? *width : *CSSInitialValue::create(), important);
         addProperty(CSSPropertyBorderImageOutset, CSSPropertyBorderImage,
                     outset ? *outset : *CSSInitialValue::create(), important);
         addProperty(CSSPropertyBorderImageRepeat, CSSPropertyBorderImage,
                     repeat ? *repeat : *CSSInitialValue::create(), important);
         return true;
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return false;
     }
   }
   return false;
 }
 
 static inline CSSValueID mapFromPageBreakBetween(CSSValueID value) {
   if (value == CSSValueAlways)
     return CSSValuePage;
   if (value == CSSValueAuto || value == CSSValueAvoid ||
@@ skipping 16 matching lines @@
   return CSSValueInvalid;
 }
 
 static inline CSSPropertyID mapFromLegacyBreakProperty(CSSPropertyID property) {
   if (property == CSSPropertyPageBreakAfter ||
       property == CSSPropertyWebkitColumnBreakAfter)
     return CSSPropertyBreakAfter;
   if (property == CSSPropertyPageBreakBefore ||
       property == CSSPropertyWebkitColumnBreakBefore)
     return CSSPropertyBreakBefore;
-  ASSERT(property == CSSPropertyPageBreakInside ||
+  DCHECK(property == CSSPropertyPageBreakInside ||
          property == CSSPropertyWebkitColumnBreakInside);
   return CSSPropertyBreakInside;
 }
 
 bool CSSPropertyParser::consumeLegacyBreakProperty(CSSPropertyID property,
                                                    bool important) {
   // The fragmentation spec says that page-break-(after|before|inside) are to be
   // treated as shorthands for their break-(after|before|inside) counterparts.
   // We'll do the same for the non-standard properties
   // -webkit-column-break-(after|before|inside).
@@ skipping 10 matching lines @@
       break;
     case CSSPropertyWebkitColumnBreakAfter:
     case CSSPropertyWebkitColumnBreakBefore:
       value = mapFromColumnBreakBetween(value);
       break;
     case CSSPropertyPageBreakInside:
     case CSSPropertyWebkitColumnBreakInside:
       value = mapFromColumnOrPageBreakInside(value);
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
   if (value == CSSValueInvalid)
     return false;
 
   CSSPropertyID genericBreakProperty = mapFromLegacyBreakProperty(property);
   addProperty(genericBreakProperty, property,
               *CSSIdentifierValue::create(value), important);
   return true;
 }
 
@@ skipping 59 matching lines @@
   return true;
 }
 
 // Note: consumeBackgroundShorthand assumes y properties (for example
 // background-position-y) follow the x properties in the shorthand array.
 bool CSSPropertyParser::consumeBackgroundShorthand(
     const StylePropertyShorthand& shorthand,
     bool important) {
   const unsigned longhandCount = shorthand.length();
   CSSValue* longhands[10] = {0};
-  ASSERT(longhandCount <= 10);
+  DCHECK_LE(longhandCount, 10u);
 
   bool implicit = false;
   do {
     bool parsedLonghand[10] = {false};
     CSSValue* originValue = nullptr;
     do {
       bool foundProperty = false;
       for (size_t i = 0; i < longhandCount; ++i) {
         if (parsedLonghand[i])
           continue;
@@ skipping 69 matching lines @@
         m_context->useLegacyBackgroundSizeShorthandBehavior())
       continue;
     addProperty(property, shorthand.id(), *longhands[i], important, implicit);
   }
   return true;
 }
 
 bool CSSPropertyParser::consumeGridItemPositionShorthand(
     CSSPropertyID shorthandId,
     bool important) {
-  ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+  DCHECK(RuntimeEnabledFeatures::cssGridLayoutEnabled());
   const StylePropertyShorthand& shorthand = shorthandForProperty(shorthandId);
-  ASSERT(shorthand.length() == 2);
+  DCHECK_EQ(shorthand.length(), 2u);
   CSSValue* startValue = consumeGridLine(m_range);
   if (!startValue)
     return false;
 
   CSSValue* endValue = nullptr;
   if (consumeSlashIncludingWhitespace(m_range)) {
     endValue = consumeGridLine(m_range);
     if (!endValue)
       return false;
   } else {
     endValue = startValue->isCustomIdentValue()
                    ? startValue
                    : CSSIdentifierValue::create(CSSValueAuto);
   }
   if (!m_range.atEnd())
     return false;
   addProperty(shorthand.properties()[0], shorthandId, *startValue, important);
   addProperty(shorthand.properties()[1], shorthandId, *endValue, important);
   return true;
 }
 
 bool CSSPropertyParser::consumeGridAreaShorthand(bool important) {
-  ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
-  ASSERT(gridAreaShorthand().length() == 4);
+  DCHECK(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+  DCHECK_EQ(gridAreaShorthand().length(), 4u);
   CSSValue* rowStartValue = consumeGridLine(m_range);
   if (!rowStartValue)
     return false;
   CSSValue* columnStartValue = nullptr;
   CSSValue* rowEndValue = nullptr;
   CSSValue* columnEndValue = nullptr;
   if (consumeSlashIncludingWhitespace(m_range)) {
     columnStartValue = consumeGridLine(m_range);
     if (!columnStartValue)
       return false;
@@ skipping 95 matching lines @@
               important);
   addProperty(
       CSSPropertyGridTemplateAreas, shorthandId,
       *CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount),
       important);
   return true;
 }
 
 bool CSSPropertyParser::consumeGridTemplateShorthand(CSSPropertyID shorthandId,
                                                      bool important) {
-  ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
-  ASSERT(gridTemplateShorthand().length() == 3);
+  DCHECK(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+  DCHECK_EQ(gridTemplateShorthand().length(), 3u);
 
   CSSParserTokenRange rangeCopy = m_range;
   CSSValue* rowsValue = consumeIdent<CSSValueNone>(m_range);
 
   // 1- 'none' case.
   if (rowsValue && m_range.atEnd()) {
     addProperty(CSSPropertyGridTemplateRows, shorthandId,
                 *CSSIdentifierValue::create(CSSValueNone), important);
     addProperty(CSSPropertyGridTemplateColumns, shorthandId,
                 *CSSIdentifierValue::create(CSSValueNone), important);
@@ skipping 43 matching lines @@
       return nullptr;
   }
   CSSValueList* list = CSSValueList::createSpaceSeparated();
   list->append(flowDirection);
   if (denseAlgorithm)
     list->append(*denseAlgorithm);
   return list;
 }
 
 bool CSSPropertyParser::consumeGridShorthand(bool important) {
-  ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
-  ASSERT(shorthandForProperty(CSSPropertyGrid).length() == 8);
+  DCHECK(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+  DCHECK_EQ(shorthandForProperty(CSSPropertyGrid).length(), 8u);
 
   CSSParserTokenRange rangeCopy = m_range;
 
   // 1- <grid-template>
   if (consumeGridTemplateShorthand(CSSPropertyGrid, important)) {
     // It can only be specified the explicit or the implicit grid properties in
     // a single grid declaration. The sub-properties not specified are set to
     // their initial value, as normal for shorthands.
     addProperty(CSSPropertyGridAutoFlow, CSSPropertyGrid,
                 *CSSInitialValue::create(), important);
@@ skipping 204 matching lines @@
     case CSSPropertyColumns:
       return consumeColumns(important);
     case CSSPropertyAnimation:
       return consumeAnimationShorthand(
           animationShorthandForParsing(),
           unresolvedProperty == CSSPropertyAliasWebkitAnimation, important);
     case CSSPropertyTransition:
       return consumeAnimationShorthand(transitionShorthandForParsing(), false,
                                        important);
     case CSSPropertyTextDecoration:
-      ASSERT(RuntimeEnabledFeatures::css3TextDecorationsEnabled());
+      DCHECK(RuntimeEnabledFeatures::css3TextDecorationsEnabled());
       return consumeShorthandGreedily(textDecorationShorthand(), important);
     case CSSPropertyMargin:
       return consume4Values(marginShorthand(), important);
     case CSSPropertyPadding:
       return consume4Values(paddingShorthand(), important);
     case CSSPropertyMotion:
       return consumeShorthandGreedily(motionShorthand(), important);
     case CSSPropertyOffset:
       return consumeOffsetShorthand(important);
     case CSSPropertyWebkitTextEmphasis:
@@ skipping 113 matching lines @@
                       ? CSSPropertyBackgroundRepeatY
                       : CSSPropertyWebkitMaskRepeatY,
                   property, *resultY, important, implicit);
       return true;
     }
     case CSSPropertyBackground:
       return consumeBackgroundShorthand(backgroundShorthand(), important);
     case CSSPropertyWebkitMask:
       return consumeBackgroundShorthand(webkitMaskShorthand(), important);
     case CSSPropertyGridGap: {
-      ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled() &&
-             shorthandForProperty(CSSPropertyGridGap).length() == 2);
+      DCHECK(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+      DCHECK_EQ(shorthandForProperty(CSSPropertyGridGap).length(), 2u);
       CSSValue* rowGap = consumeLengthOrPercent(m_range, m_context->mode(),
                                                 ValueRangeNonNegative);
       CSSValue* columnGap = consumeLengthOrPercent(m_range, m_context->mode(),
                                                    ValueRangeNonNegative);
       if (!rowGap || !m_range.atEnd())
         return false;
       if (!columnGap)
         columnGap = rowGap;
       addProperty(CSSPropertyGridRowGap, CSSPropertyGridGap, *rowGap,
                   important);
@@ skipping 11 matching lines @@
     case CSSPropertyGrid:
       return consumeGridShorthand(important);
     case CSSPropertyPlaceContent:
       return consumePlaceContentShorthand(important);
     default:
       return false;
   }
 }
 
 }  // namespace blink