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

third_party/WebKit/Source/core/css/parser/CSSParserToken.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/CSSParserToken.h"
 
 #include "core/css/CSSMarkup.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/parser/CSSPropertyParser.h"
 #include "wtf/HashMap.h"
 #include "wtf/text/StringBuilder.h"
 #include <limits.h>
 
 namespace blink {
 
 CSSParserToken::CSSParserToken(CSSParserTokenType type, BlockType blockType)
     : m_type(type), m_blockType(blockType) {}
 
 // Just a helper used for Delimiter tokens.
 CSSParserToken::CSSParserToken(CSSParserTokenType type, UChar c)
     : m_type(type), m_blockType(NotBlock), m_delimiter(c) {
-  ASSERT(m_type == DelimiterToken);
+  DCHECK_EQ(m_type, static_cast<unsigned>(DelimiterToken));
 }
 
 CSSParserToken::CSSParserToken(CSSParserTokenType type,
                                StringView value,
                                BlockType blockType)
     : m_type(type), m_blockType(blockType) {
   initValueFromStringView(value);
   m_id = -1;
 }
 
 CSSParserToken::CSSParserToken(CSSParserTokenType type,
                                double numericValue,
                                NumericValueType numericValueType,
                                NumericSign sign)
     : m_type(type),
       m_blockType(NotBlock),
       m_numericValueType(numericValueType),
       m_numericSign(sign),
       m_unit(static_cast<unsigned>(CSSPrimitiveValue::UnitType::Number)) {
-  ASSERT(type == NumberToken);
+  DCHECK_EQ(type, NumberToken);
   m_numericValue =
       clampTo<double>(numericValue, -std::numeric_limits<float>::max(),
                       std::numeric_limits<float>::max());
 }
 
 CSSParserToken::CSSParserToken(CSSParserTokenType type,
                                UChar32 start,
                                UChar32 end)
     : m_type(UnicodeRangeToken), m_blockType(NotBlock) {
   DCHECK_EQ(type, UnicodeRangeToken);
   m_unicodeRange.start = start;
   m_unicodeRange.end = end;
 }
 
 CSSParserToken::CSSParserToken(HashTokenType type, StringView value)
     : m_type(HashToken), m_blockType(NotBlock), m_hashTokenType(type) {
   initValueFromStringView(value);
 }
 
 void CSSParserToken::convertToDimensionWithUnit(StringView unit) {
-  ASSERT(m_type == NumberToken);
+  DCHECK_EQ(m_type, static_cast<unsigned>(NumberToken));
   m_type = DimensionToken;
   initValueFromStringView(unit);
   m_unit = static_cast<unsigned>(CSSPrimitiveValue::stringToUnitType(unit));
 }
 
 void CSSParserToken::convertToPercentage() {
-  ASSERT(m_type == NumberToken);
+  DCHECK_EQ(m_type, static_cast<unsigned>(NumberToken));
   m_type = PercentageToken;
   m_unit = static_cast<unsigned>(CSSPrimitiveValue::UnitType::Percentage);
 }
 
 UChar CSSParserToken::delimiter() const {
-  ASSERT(m_type == DelimiterToken);
+  DCHECK_EQ(m_type, static_cast<unsigned>(DelimiterToken));
   return m_delimiter;
 }
 
 NumericSign CSSParserToken::numericSign() const {
   // This is valid for DimensionToken and PercentageToken, but only used
   // in <an+b> parsing on NumberTokens.
-  ASSERT(m_type == NumberToken);
+  DCHECK_EQ(m_type, static_cast<unsigned>(NumberToken));
   return static_cast<NumericSign>(m_numericSign);
 }
 
 NumericValueType CSSParserToken::numericValueType() const {
-  ASSERT(m_type == NumberToken || m_type == PercentageToken ||
+  DCHECK(m_type == NumberToken || m_type == PercentageToken ||
          m_type == DimensionToken);
   return static_cast<NumericValueType>(m_numericValueType);
 }
 
 double CSSParserToken::numericValue() const {
-  ASSERT(m_type == NumberToken || m_type == PercentageToken ||
+  DCHECK(m_type == NumberToken || m_type == PercentageToken ||
          m_type == DimensionToken);
   return m_numericValue;
 }
 
 CSSPropertyID CSSParserToken::parseAsUnresolvedCSSPropertyID() const {
-  ASSERT(m_type == IdentToken);
+  DCHECK_EQ(m_type, static_cast<unsigned>(IdentToken));
   return unresolvedCSSPropertyID(value());
 }
 
 CSSValueID CSSParserToken::id() const {
   if (m_type != IdentToken)
     return CSSValueInvalid;
   if (m_id < 0)
     m_id = cssValueKeywordID(value());
   return static_cast<CSSValueID>(m_id);
 }
@@ skipping 160 matching lines @@
       return builder.append('[');
     case RightBracketToken:
       return builder.append(']');
     case LeftBraceToken:
       return builder.append('{');
     case RightBraceToken:
       return builder.append('}');
 
     case EOFToken:
     case CommentToken:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return;
   }
 }
 
 }  // namespace blink