Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/html/parser/

third_party/WebKit/Source/core/html/parser/HTMLTokenizer.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Torch Mobile, Inc. http://www.torchmobile.com/
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 27 matching lines @@
 
 // Please don't use DEFINE_STATIC_LOCAL in this file. The HTMLTokenizer is used
 // from multiple threads and DEFINE_STATIC_LOCAL isn't threadsafe.
 #undef DEFINE_STATIC_LOCAL
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static inline UChar toLowerCase(UChar cc) {
-  ASSERT(isASCIIUpper(cc));
+  DCHECK(isASCIIUpper(cc));
   const int lowerCaseOffset = 0x20;
   return cc + lowerCaseOffset;
 }
 
 static inline bool vectorEqualsString(const Vector<LChar, 32>& vector,
                                       const String& string) {
   if (vector.size() != string.length())
     return false;
 
   if (!string.length())
@@ skipping 22 matching lines @@
   m_additionalAllowedCharacter = '\0';
 }
 
 inline bool HTMLTokenizer::processEntity(SegmentedString& source) {
   bool notEnoughCharacters = false;
   DecodedHTMLEntity decodedEntity;
   bool success = consumeHTMLEntity(source, decodedEntity, notEnoughCharacters);
   if (notEnoughCharacters)
     return false;
   if (!success) {
-    ASSERT(decodedEntity.isEmpty());
+    DCHECK(decodedEntity.isEmpty());
     bufferCharacter('&');
   } else {
     for (unsigned i = 0; i < decodedEntity.length; ++i)
       bufferCharacter(decodedEntity.data[i]);
   }
   return true;
 }
 
 bool HTMLTokenizer::flushBufferedEndTag(SegmentedString& source) {
-  ASSERT(m_token->type() == HTMLToken::Character ||
+  DCHECK(m_token->type() == HTMLToken::Character ||
          m_token->type() == HTMLToken::Uninitialized);
   source.advanceAndUpdateLineNumber();
   if (m_token->type() == HTMLToken::Character)
     return true;
   m_token->beginEndTag(m_bufferedEndTagName);
   m_bufferedEndTagName.clear();
   m_appropriateEndTagName.clear();
   m_temporaryBuffer.clear();
   return false;
 }
@@ skipping 12 matching lines @@
 bool HTMLTokenizer::flushEmitAndResumeIn(SegmentedString& source,
                                          HTMLTokenizer::State state) {
   m_state = state;
   flushBufferedEndTag(source);
   return true;
 }
 
 bool HTMLTokenizer::nextToken(SegmentedString& source, HTMLToken& token) {
   // If we have a token in progress, then we're supposed to be called back
   // with the same token so we can finish it.
-  ASSERT(!m_token || m_token == &token ||
+  DCHECK(!m_token || m_token == &token ||
          token.type() == HTMLToken::Uninitialized);
   m_token = &token;
 
   if (!m_bufferedEndTagName.isEmpty() && !isEndTagBufferingState(m_state)) {
     // FIXME: This should call flushBufferedEndTag().
     // We started an end tag during our last iteration.
     m_token->beginEndTag(m_bufferedEndTagName);
     m_bufferedEndTagName.clear();
     m_appropriateEndTagName.clear();
     m_temporaryBuffer.clear();
@@ skipping 153 matching lines @@
       } else {
         m_token->appendToName(cc);
         HTML_ADVANCE_TO(TagNameState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(RCDATALessThanSignState) {
       if (cc == '/') {
         m_temporaryBuffer.clear();
-        ASSERT(m_bufferedEndTagName.isEmpty());
+        DCHECK(m_bufferedEndTagName.isEmpty());
         HTML_ADVANCE_TO(RCDATAEndTagOpenState);
       } else {
         bufferCharacter('<');
         HTML_RECONSUME_IN(RCDATAState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(RCDATAEndTagOpenState) {
       if (isASCIIUpper(cc)) {
@@ skipping 44 matching lines @@
         m_bufferedEndTagName.clear();
         m_temporaryBuffer.clear();
         HTML_RECONSUME_IN(RCDATAState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(RAWTEXTLessThanSignState) {
       if (cc == '/') {
         m_temporaryBuffer.clear();
-        ASSERT(m_bufferedEndTagName.isEmpty());
+        DCHECK(m_bufferedEndTagName.isEmpty());
         HTML_ADVANCE_TO(RAWTEXTEndTagOpenState);
       } else {
         bufferCharacter('<');
         HTML_RECONSUME_IN(RAWTEXTState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(RAWTEXTEndTagOpenState) {
       if (isASCIIUpper(cc)) {
@@ skipping 44 matching lines @@
         m_bufferedEndTagName.clear();
         m_temporaryBuffer.clear();
         HTML_RECONSUME_IN(RAWTEXTState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(ScriptDataLessThanSignState) {
       if (cc == '/') {
         m_temporaryBuffer.clear();
-        ASSERT(m_bufferedEndTagName.isEmpty());
+        DCHECK(m_bufferedEndTagName.isEmpty());
         HTML_ADVANCE_TO(ScriptDataEndTagOpenState);
       } else if (cc == '!') {
         bufferCharacter('<');
         bufferCharacter('!');
         HTML_ADVANCE_TO(ScriptDataEscapeStartState);
       } else {
         bufferCharacter('<');
         HTML_RECONSUME_IN(ScriptDataState);
       }
     }
@@ skipping 117 matching lines @@
       } else {
         bufferCharacter(cc);
         HTML_ADVANCE_TO(ScriptDataEscapedState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(ScriptDataEscapedLessThanSignState) {
       if (cc == '/') {
         m_temporaryBuffer.clear();
-        ASSERT(m_bufferedEndTagName.isEmpty());
+        DCHECK(m_bufferedEndTagName.isEmpty());
         HTML_ADVANCE_TO(ScriptDataEscapedEndTagOpenState);
       } else if (isASCIIUpper(cc)) {
         bufferCharacter('<');
         bufferCharacter(cc);
         m_temporaryBuffer.clear();
         m_temporaryBuffer.push_back(toLowerCase(cc));
         HTML_ADVANCE_TO(ScriptDataDoubleEscapeStartState);
       } else if (isASCIILower(cc)) {
         bufferCharacter('<');
         bufferCharacter(cc);
@@ skipping 336 matching lines @@
 
     HTML_BEGIN_STATE(CharacterReferenceInAttributeValueState) {
       bool notEnoughCharacters = false;
       DecodedHTMLEntity decodedEntity;
       bool success =
           consumeHTMLEntity(source, decodedEntity, notEnoughCharacters,
                             m_additionalAllowedCharacter);
       if (notEnoughCharacters)
         return haveBufferedCharacterToken();
       if (!success) {
-        ASSERT(decodedEntity.isEmpty());
+        DCHECK(decodedEntity.isEmpty());
         m_token->appendToAttributeValue('&');
       } else {
         for (unsigned i = 0; i < decodedEntity.length; ++i)
           m_token->appendToAttributeValue(decodedEntity.data[i]);
       }
       // We're supposed to switch back to the attribute value state that
       // we were in when we were switched into this state. Rather than
       // keeping track of this explictly, we observe that the previous
       // state can be determined by m_additionalAllowedCharacter.
       if (m_additionalAllowedCharacter == '"')
         HTML_SWITCH_TO(AttributeValueDoubleQuotedState);
       else if (m_additionalAllowedCharacter == '\'')
         HTML_SWITCH_TO(AttributeValueSingleQuotedState);
       else if (m_additionalAllowedCharacter == '>')
         HTML_SWITCH_TO(AttributeValueUnquotedState);
       else
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
     END_STATE()
 
     HTML_BEGIN_STATE(AfterAttributeValueQuotedState) {
       if (isTokenizerWhitespace(cc))
         HTML_ADVANCE_TO(BeforeAttributeNameState);
       else if (cc == '/')
         HTML_ADVANCE_TO(SelfClosingStartTagState);
       else if (cc == '>')
         return emitAndResumeIn(source, HTMLTokenizer::DataState);
@@ skipping 545 matching lines @@
         HTML_ADVANCE_TO(DataState);
       } else {
         bufferCharacter(']');
         bufferCharacter(']');
         HTML_RECONSUME_IN(CDATASectionState);
       }
     }
     END_STATE()
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return false;
 }
 
 String HTMLTokenizer::bufferedCharacters() const {
   // FIXME: Add an assert about m_state.
   StringBuilder characters;
   characters.reserveCapacity(numberOfBufferedCharacters());
   characters.append('<');
   characters.append('/');
   characters.append(m_temporaryBuffer.data(), m_temporaryBuffer.size());
@@ skipping 15 matching lines @@
            threadSafeMatch(tagName, noframesTag) ||
            (threadSafeMatch(tagName, noscriptTag) && m_options.scriptEnabled))
     setState(HTMLTokenizer::RAWTEXTState);
 }
 
 inline bool HTMLTokenizer::temporaryBufferIs(const String& expectedString) {
   return vectorEqualsString(m_temporaryBuffer, expectedString);
 }
 
 inline void HTMLTokenizer::addToPossibleEndTag(LChar cc) {
-  ASSERT(isEndTagBufferingState(m_state));
+  DCHECK(isEndTagBufferingState(m_state));
   m_bufferedEndTagName.push_back(cc);
 }
 
 inline bool HTMLTokenizer::isAppropriateEndTag() {
   if (m_bufferedEndTagName.size() != m_appropriateEndTagName.size())
     return false;
 
   size_t numCharacters = m_bufferedEndTagName.size();
 
   for (size_t i = 0; i < numCharacters; i++) {
     if (m_bufferedEndTagName[i] != m_appropriateEndTagName[i])
       return false;
   }
 
   return true;
 }
 
 inline void HTMLTokenizer::parseError() {
 #if DCHECK_IS_ON()
   DVLOG(1) << "Not implemented.";
 #endif
 }
 
 }  // namespace blink