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

third_party/WebKit/Source/core/css/parser/CSSParserImpl.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/CSSParserImpl.h"
 
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
@@ skipping 310 matching lines @@
 
   return createStylePropertySet(parser.m_parsedProperties, HTMLStandardMode);
 }
 
 std::unique_ptr<Vector<double>> CSSParserImpl::parseKeyframeKeyList(
     const String& keyList) {
   return consumeKeyframeKeyList(CSSTokenizer(keyList).tokenRange());
 }
 
 bool CSSParserImpl::supportsDeclaration(CSSParserTokenRange& range) {
-  ASSERT(m_parsedProperties.isEmpty());
+  DCHECK(m_parsedProperties.isEmpty());
   consumeDeclaration(range, StyleRule::Style);
   bool result = !m_parsedProperties.isEmpty();
   m_parsedProperties.clear();
   return result;
 }
 
 void CSSParserImpl::parseDeclarationListForInspector(
     const String& declaration,
     const CSSParserContext* context,
     CSSParserObserver& observer) {
@@ skipping 31 matching lines @@
   parser.consumeDeclarationList(std::move(block), StyleRule::Style);
   return createStylePropertySet(parser.m_parsedProperties, context->mode());
 }
 
 static CSSParserImpl::AllowedRulesType computeNewAllowedRules(
     CSSParserImpl::AllowedRulesType allowedRules,
     StyleRuleBase* rule) {
   if (!rule || allowedRules == CSSParserImpl::KeyframeRules ||
       allowedRules == CSSParserImpl::NoRules)
     return allowedRules;
-  ASSERT(allowedRules <= CSSParserImpl::RegularRules);
+  DCHECK_LE(allowedRules, CSSParserImpl::RegularRules);
   if (rule->isCharsetRule() || rule->isImportRule())
     return CSSParserImpl::AllowImportRules;
   if (rule->isNamespaceRule())
     return CSSParserImpl::AllowNamespaceRules;
   return CSSParserImpl::RegularRules;
 }
 
 template <typename T>
 bool CSSParserImpl::consumeRuleList(CSSParserTokenRange range,
                                     RuleListType ruleListType,
                                     const T callback) {
   AllowedRulesType allowedRules = RegularRules;
   switch (ruleListType) {
     case TopLevelRuleList:
       allowedRules = AllowCharsetRules;
       break;
     case RegularRuleList:
       allowedRules = RegularRules;
       break;
     case KeyframesRuleList:
       allowedRules = KeyframeRules;
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 
   bool seenRule = false;
   bool firstRuleValid = false;
   while (!range.atEnd()) {
     StyleRuleBase* rule;
     switch (range.peek().type()) {
       case WhitespaceToken:
         range.consumeWhitespace();
         continue;
@@ skipping 19 matching lines @@
       allowedRules = computeNewAllowedRules(allowedRules, rule);
       callback(rule);
     }
   }
 
   return firstRuleValid;
 }
 
 StyleRuleBase* CSSParserImpl::consumeAtRule(CSSParserTokenRange& range,
                                             AllowedRulesType allowedRules) {
-  ASSERT(range.peek().type() == AtKeywordToken);
+  DCHECK_EQ(range.peek().type(), AtKeywordToken);
   const StringView name = range.consumeIncludingWhitespace().value();
   const CSSParserToken* preludeStart = &range.peek();
   while (!range.atEnd() && range.peek().type() != LeftBraceToken &&
          range.peek().type() != SemicolonToken)
     range.consumeComponentValue();
 
   CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek());
   CSSAtRuleID id = cssAtRuleID(name);
   if (id != CSSAtRuleInvalid && m_context->isUseCounterRecordingEnabled())
     countAtRule(m_context, id);
@@ skipping 13 matching lines @@
     return nullptr;  // Parse error, unrecognised at-rule without block
   }
 
   CSSParserTokenRange block = range.consumeBlock();
   if (allowedRules == KeyframeRules)
     return nullptr;  // Parse error, no at-rules supported inside @keyframes
   if (allowedRules == NoRules || allowedRules == ApplyRules)
     return nullptr;  // Parse error, no at-rules with blocks supported inside
                      // declaration lists
 
-  ASSERT(allowedRules <= RegularRules);
+  DCHECK_LE(allowedRules, RegularRules);
 
   switch (id) {
     case CSSAtRuleMedia:
       return consumeMediaRule(prelude, block);
     case CSSAtRuleSupports:
       return consumeSupportsRule(prelude, block);
     case CSSAtRuleViewport:
       return consumeViewportRule(prelude, block);
     case CSSAtRuleFontFace:
       return consumeFontFaceRule(prelude, block);
@@ skipping 19 matching lines @@
     return nullptr;  // Parse error, EOF instead of qualified rule block
 
   CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek());
   CSSParserTokenRange block = range.consumeBlock();
 
   if (allowedRules <= RegularRules)
     return consumeStyleRule(prelude, block);
   if (allowedRules == KeyframeRules)
     return consumeKeyframeStyleRule(prelude, block);
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return nullptr;
 }
 
 // This may still consume tokens if it fails
 static AtomicString consumeStringOrURI(CSSParserTokenRange& range) {
   const CSSParserToken& token = range.peek();
 
   if (token.type() == StringToken || token.type() == UrlToken)
     return range.consumeIncludingWhitespace().value().toAtomicString();
 
@@ skipping 211 matching lines @@
   }
 
   consumeDeclarationList(block, StyleRule::Style);
 
   return StyleRulePage::create(
       std::move(selectorList),
       createStylePropertySet(m_parsedProperties, m_context->mode()));
 }
 
 void CSSParserImpl::consumeApplyRule(CSSParserTokenRange prelude) {
-  ASSERT(RuntimeEnabledFeatures::cssApplyAtRulesEnabled());
+  DCHECK(RuntimeEnabledFeatures::cssApplyAtRulesEnabled());
 
   const CSSParserToken& ident = prelude.consumeIncludingWhitespace();
   if (!prelude.atEnd() || !CSSVariableParser::isValidVariableName(ident))
     return;  // Parse error, expected a single custom property name
   m_parsedProperties.push_back(CSSProperty(
       CSSPropertyApplyAtRule,
       *CSSCustomIdentValue::create(ident.value().toAtomicString())));
 }
 
 StyleRuleKeyframe* CSSParserImpl::consumeKeyframeStyleRule(
@@ skipping 57 matching lines @@
   }
   consumeDeclarationList(block, StyleRule::Style);
 
   return StyleRule::create(
       std::move(selectorList),
       createStylePropertySet(m_parsedProperties, m_context->mode()));
 }
 
 void CSSParserImpl::consumeDeclarationList(CSSParserTokenRange range,
                                            StyleRule::RuleType ruleType) {
-  ASSERT(m_parsedProperties.isEmpty());
+  DCHECK(m_parsedProperties.isEmpty());
 
   bool useObserver = m_observerWrapper && (ruleType == StyleRule::Style ||
                                            ruleType == StyleRule::Keyframe);
   if (useObserver) {
     m_observerWrapper->observer().startRuleBody(
         m_observerWrapper->previousTokenStartOffset(range));
     m_observerWrapper->skipCommentsBefore(range, true);
   }
 
   while (!range.atEnd()) {
@@ skipping 40 matching lines @@
     m_observerWrapper->yieldCommentsBefore(range);
     m_observerWrapper->observer().endRuleBody(
         m_observerWrapper->endOffset(range));
   }
 }
 
 void CSSParserImpl::consumeDeclaration(CSSParserTokenRange range,
                                        StyleRule::RuleType ruleType) {
   CSSParserTokenRange rangeCopy = range;  // For inspector callbacks
 
-  ASSERT(range.peek().type() == IdentToken);
+  DCHECK_EQ(range.peek().type(), IdentToken);
   const CSSParserToken& token = range.consumeIncludingWhitespace();
   CSSPropertyID unresolvedProperty = token.parseAsUnresolvedCSSPropertyID();
   if (range.consume().type() != ColonToken)
     return;  // Parse error
 
   bool important = false;
   const CSSParserToken* declarationValueEnd = range.end();
   const CSSParserToken* last = range.end() - 1;
   while (last->type() == WhitespaceToken)
     --last;
@@ skipping 78 matching lines @@
     else
       return nullptr;  // Parser error, invalid value in keyframe selector
     if (range.atEnd())
       return result;
     if (range.consume().type() != CommaToken)
       return nullptr;  // Parser error
   }
 }
 
 }  // namespace blink