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

third_party/WebKit/Source/core/css/parser/CSSParserFastPaths.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 "core/css/parser/CSSParserFastPaths.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSColorValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSIdentifierValue.h"
@@ skipping 87 matching lines @@
   if (!ok)
     return false;
   number = clampTo<double>(number, -std::numeric_limits<float>::max(),
                            std::numeric_limits<float>::max());
   return true;
 }
 
 static CSSValue* parseSimpleLengthValue(CSSPropertyID propertyId,
                                         const String& string,
                                         CSSParserMode cssParserMode) {
-  ASSERT(!string.isEmpty());
+  DCHECK(!string.isEmpty());
   bool acceptsNegativeNumbers = false;
 
   // In @viewport, width and height are shorthands, not simple length values.
   if (isCSSViewportParsingEnabledForMode(cssParserMode) ||
       !isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers))
     return nullptr;
 
   unsigned length = string.length();
   double number;
   CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::UnitType::Number;
@@ skipping 346 matching lines @@
       return false;
     rgb = makeRGB(red, green, blue);
     return true;
   }
 
   return false;
 }
 
 CSSValue* CSSParserFastPaths::parseColor(const String& string,
                                          CSSParserMode parserMode) {
-  ASSERT(!string.isEmpty());
+  DCHECK(!string.isEmpty());
   CSSValueID valueID = cssValueKeywordID(string);
   if (StyleColor::isColorKeyword(valueID)) {
     if (!isValueAllowedInMode(valueID, parserMode))
       return nullptr;
     return CSSIdentifierValue::create(valueID);
   }
 
   RGBA32 color;
   bool quirksMode = isQuirksModeBehavior(parserMode);
 
@@ skipping 140 matching lines @@
     case CSSPropertyPosition:
       return valueID == CSSValueStatic || valueID == CSSValueRelative ||
              valueID == CSSValueAbsolute || valueID == CSSValueFixed ||
              (RuntimeEnabledFeatures::cssStickyPositionEnabled() &&
               valueID == CSSValueSticky);
     case CSSPropertyResize:
       return valueID == CSSValueNone || valueID == CSSValueBoth ||
              valueID == CSSValueHorizontal || valueID == CSSValueVertical ||
              valueID == CSSValueAuto;
     case CSSPropertyScrollBehavior:
-      ASSERT(RuntimeEnabledFeatures::cssomSmoothScrollEnabled());
+      DCHECK(RuntimeEnabledFeatures::cssomSmoothScrollEnabled());
       return valueID == CSSValueAuto || valueID == CSSValueSmooth;
     case CSSPropertyShapeRendering:
       return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed ||
              valueID == CSSValueCrispEdges ||
              valueID == CSSValueGeometricPrecision;
     case CSSPropertySpeak:
       return valueID == CSSValueNone || valueID == CSSValueNormal ||
              valueID == CSSValueSpellOut || valueID == CSSValueDigits ||
              valueID == CSSValueLiteralPunctuation ||
              valueID == CSSValueNoPunctuation;
@@ skipping 12 matching lines @@
     case CSSPropertyTextAlignLast:
       return (valueID >= CSSValueLeft && valueID <= CSSValueJustify) ||
              valueID == CSSValueStart || valueID == CSSValueEnd ||
              valueID == CSSValueAuto;
     case CSSPropertyTextAnchor:
       return valueID == CSSValueStart || valueID == CSSValueMiddle ||
              valueID == CSSValueEnd;
     case CSSPropertyTextCombineUpright:
       return valueID == CSSValueNone || valueID == CSSValueAll;
     case CSSPropertyTextDecorationStyle:
-      ASSERT(RuntimeEnabledFeatures::css3TextDecorationsEnabled());
+      DCHECK(RuntimeEnabledFeatures::css3TextDecorationsEnabled());
       return valueID == CSSValueSolid || valueID == CSSValueDouble ||
              valueID == CSSValueDotted || valueID == CSSValueDashed ||
              valueID == CSSValueWavy;
     case CSSPropertyTextJustify:
-      ASSERT(RuntimeEnabledFeatures::css3TextEnabled());
+      DCHECK(RuntimeEnabledFeatures::css3TextEnabled());
       return valueID == CSSValueInterWord || valueID == CSSValueDistribute ||
              valueID == CSSValueAuto || valueID == CSSValueNone;
     case CSSPropertyTextOrientation:
       return valueID == CSSValueMixed || valueID == CSSValueUpright ||
              valueID == CSSValueSideways || valueID == CSSValueSidewaysRight;
     case CSSPropertyWebkitTextOrientation:
       return valueID == CSSValueSideways || valueID == CSSValueSidewaysRight ||
              valueID == CSSValueVerticalRight || valueID == CSSValueUpright;
     case CSSPropertyTextOverflow:
       return valueID == CSSValueClip || valueID == CSSValueEllipsis;
@@ skipping 139 matching lines @@
              valueID == CSSValueLr || valueID == CSSValueRl ||
              valueID == CSSValueTb;
     case CSSPropertyWhiteSpace:
       return valueID == CSSValueNormal || valueID == CSSValuePre ||
              valueID == CSSValuePreWrap || valueID == CSSValuePreLine ||
              valueID == CSSValueNowrap;
     case CSSPropertyWordBreak:
       return valueID == CSSValueNormal || valueID == CSSValueBreakAll ||
              valueID == CSSValueKeepAll || valueID == CSSValueBreakWord;
     case CSSPropertyScrollSnapType:
-      ASSERT(RuntimeEnabledFeatures::cssScrollSnapPointsEnabled());
+      DCHECK(RuntimeEnabledFeatures::cssScrollSnapPointsEnabled());
       return valueID == CSSValueNone || valueID == CSSValueMandatory ||
              valueID == CSSValueProximity;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return false;
   }
 }
 
 bool CSSParserFastPaths::isKeywordPropertyID(CSSPropertyID propertyId) {
   switch (propertyId) {
     case CSSPropertyAlignmentBaseline:
     case CSSPropertyAll:
     case CSSPropertyMixBlendMode:
     case CSSPropertyIsolation:
@@ skipping 104 matching lines @@
     case CSSPropertyAlignSelf:
       return !RuntimeEnabledFeatures::cssGridLayoutEnabled();
     default:
       return false;
   }
 }
 
 static CSSValue* parseKeywordValue(CSSPropertyID propertyId,
                                    const String& string,
                                    CSSParserMode parserMode) {
-  ASSERT(!string.isEmpty());
+  DCHECK(!string.isEmpty());
 
   if (!CSSParserFastPaths::isKeywordPropertyID(propertyId)) {
     // All properties accept the values of "initial" and "inherit".
     if (!equalIgnoringASCIICase(string, "initial") &&
         !equalIgnoringASCIICase(string, "inherit"))
       return nullptr;
 
     // Parse initial/inherit shorthands using the CSSPropertyParser.
     if (shorthandForProperty(propertyId).length())
       return nullptr;
@@ skipping 210 matching lines @@
       return nullptr;
     if (!transformList)
       transformList = CSSValueList::createSpaceSeparated();
     transformList->append(*transformValue);
   }
   return transformList;
 }
 
 static CSSValue* parseSimpleTransform(CSSPropertyID propertyID,
                                       const String& string) {
-  ASSERT(!string.isEmpty());
+  DCHECK(!string.isEmpty());
 
   if (propertyID != CSSPropertyTransform)
     return nullptr;
   if (string.is8Bit())
     return parseSimpleTransformList(string.characters8(), string.length());
   return parseSimpleTransformList(string.characters16(), string.length());
 }
 
 CSSValue* CSSParserFastPaths::maybeParseValue(CSSPropertyID propertyID,
                                               const String& string,
                                               CSSParserMode parserMode) {
   if (CSSValue* length = parseSimpleLengthValue(propertyID, string, parserMode))
     return length;
   if (isColorPropertyID(propertyID))
     return parseColor(string, parserMode);
   if (CSSValue* keyword = parseKeywordValue(propertyID, string, parserMode))
     return keyword;
   if (CSSValue* transform = parseSimpleTransform(propertyID, string))
     return transform;
   return nullptr;
 }
 
 }  // namespace blink