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

third_party/WebKit/Source/core/css/parser/CSSSelectorParser.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/CSSSelectorParser.h"
 
 #include "core/css/CSSSelectorList.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/CSSParserContext.h"
 #include "core/frame/Deprecation.h"
@@ skipping 194 matching lines @@
     const CSSParserSelector& simpleSelector,
     CSSSelector::PseudoType compoundPseudoElement) {
   if (compoundPseudoElement == CSSSelector::PseudoUnknown)
     return true;
   if (compoundPseudoElement == CSSSelector::PseudoContent)
     return simpleSelector.match() != CSSSelector::PseudoElement;
   if (simpleSelector.match() != CSSSelector::PseudoClass)
     return false;
   CSSSelector::PseudoType pseudo = simpleSelector.pseudoType();
   if (pseudo == CSSSelector::PseudoNot) {
-    ASSERT(simpleSelector.selectorList());
-    ASSERT(simpleSelector.selectorList()->first());
-    ASSERT(!simpleSelector.selectorList()->first()->tagHistory());
+    DCHECK(simpleSelector.selectorList());
+    DCHECK(simpleSelector.selectorList()->first());
+    DCHECK(!simpleSelector.selectorList()->first()->tagHistory());
     pseudo = simpleSelector.selectorList()->first()->getPseudoType();
   }
   return isPseudoClassValidAfterPseudoElement(pseudo, compoundPseudoElement);
 }
 
 }  // namespace
 
 std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeCompoundSelector(
     CSSParserTokenRange& range) {
   std::unique_ptr<CSSParserSelector> compoundSelector;
@@ skipping 111 matching lines @@
     name = nullAtom;
     namespacePrefix = nullAtom;
     return false;
   }
 
   return true;
 }
 
 std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeId(
     CSSParserTokenRange& range) {
-  ASSERT(range.peek().type() == HashToken);
+  DCHECK_EQ(range.peek().type(), HashToken);
   if (range.peek().getHashTokenType() != HashTokenId)
     return nullptr;
   std::unique_ptr<CSSParserSelector> selector = CSSParserSelector::create();
   selector->setMatch(CSSSelector::Id);
   AtomicString value = range.consume().value().toAtomicString();
   selector->setValue(value, isQuirksModeBehavior(m_context->matchMode()));
   return selector;
 }
 
 std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeClass(
     CSSParserTokenRange& range) {
-  ASSERT(range.peek().type() == DelimiterToken);
-  ASSERT(range.peek().delimiter() == '.');
+  DCHECK_EQ(range.peek().type(), DelimiterToken);
+  DCHECK_EQ(range.peek().delimiter(), '.');
   range.consume();
   if (range.peek().type() != IdentToken)
     return nullptr;
   std::unique_ptr<CSSParserSelector> selector = CSSParserSelector::create();
   selector->setMatch(CSSSelector::Class);
   AtomicString value = range.consume().value().toAtomicString();
   selector->setValue(value, isQuirksModeBehavior(m_context->matchMode()));
   return selector;
 }
 
 std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeAttribute(
     CSSParserTokenRange& range) {
-  ASSERT(range.peek().type() == LeftBracketToken);
+  DCHECK_EQ(range.peek().type(), LeftBracketToken);
   CSSParserTokenRange block = range.consumeBlock();
   block.consumeWhitespace();
 
   AtomicString namespacePrefix;
   AtomicString attributeName;
   if (!consumeName(block, attributeName, namespacePrefix))
     return nullptr;
   if (attributeName == starAtom)
     return nullptr;
   block.consumeWhitespace();
@@ skipping 27 matching lines @@
   selector->setValue(attributeValue.value().toAtomicString());
   selector->setAttribute(qualifiedName, consumeAttributeFlags(block));
 
   if (!block.atEnd())
     return nullptr;
   return selector;
 }
 
 std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumePseudo(
     CSSParserTokenRange& range) {
-  ASSERT(range.peek().type() == ColonToken);
+  DCHECK_EQ(range.peek().type(), ColonToken);
   range.consume();
 
   int colons = 1;
   if (range.peek().type() == ColonToken) {
     range.consume();
     colons++;
   }
 
   const CSSParserToken& token = range.peek();
   if (token.type() != IdentToken && token.type() != FunctionToken)
@@ skipping 456 matching lines @@
       }
       if (current->relation() == CSSSelector::IndirectAdjacent)
         m_context->count(UseCounter::CSSSelectorIndirectAdjacent);
       if (current->selectorList())
         recordUsageAndDeprecations(*current->selectorList());
     }
   }
 }
 
 }  // namespace blink