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

third_party/WebKit/Source/core/html/parser/HTMLToken.h

 /*
  * Copyright (C) 2013 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 148 matching lines @@
     // thrash malloc. When we finally finish the parse the
     // HTMLToken will be destroyed and the VectorBuffer released.
     m_data.shrink(0);
     m_orAllData = 0;
   }
 
   bool isUninitialized() { return m_type == Uninitialized; }
   TokenType type() const { return m_type; }
 
   void makeEndOfFile() {
-    ASSERT(m_type == Uninitialized);
+    DCHECK_EQ(m_type, Uninitialized);
     m_type = EndOfFile;
   }
 
   // Range and offset methods exposed for HTMLSourceTracker and
   // HTMLViewSourceParser.
   int startIndex() const { return m_range.start; }
   int endIndex() const { return m_range.end; }
 
   void setBaseOffset(int offset) { m_baseOffset = offset; }
 
   void end(int endOffset) { m_range.end = endOffset - m_baseOffset; }
 
   const DataVector& data() const {
-    ASSERT(m_type == Character || m_type == Comment || m_type == StartTag ||
+    DCHECK(m_type == Character || m_type == Comment || m_type == StartTag ||
            m_type == EndTag);
     return m_data;
   }
 
   bool isAll8BitData() const { return (m_orAllData <= 0xff); }
 
   const DataVector& name() const {
-    ASSERT(m_type == StartTag || m_type == EndTag || m_type == DOCTYPE);
+    DCHECK(m_type == StartTag || m_type == EndTag || m_type == DOCTYPE);
     return m_data;
   }
 
   void appendToName(UChar character) {
-    ASSERT(m_type == StartTag || m_type == EndTag || m_type == DOCTYPE);
-    ASSERT(character);
+    DCHECK(m_type == StartTag || m_type == EndTag || m_type == DOCTYPE);
+    DCHECK(character);
     m_data.push_back(character);
     m_orAllData |= character;
   }
 
   /* DOCTYPE Tokens */
 
   bool forceQuirks() const {
-    ASSERT(m_type == DOCTYPE);
+    DCHECK_EQ(m_type, DOCTYPE);
     return m_doctypeData->m_forceQuirks;
   }
 
   void setForceQuirks() {
-    ASSERT(m_type == DOCTYPE);
+    DCHECK_EQ(m_type, DOCTYPE);
     m_doctypeData->m_forceQuirks = true;
   }
 
   void beginDOCTYPE() {
-    ASSERT(m_type == Uninitialized);
+    DCHECK_EQ(m_type, Uninitialized);
     m_type = DOCTYPE;
     m_doctypeData = WTF::wrapUnique(new DoctypeData);
   }
 
   void beginDOCTYPE(UChar character) {
-    ASSERT(character);
+    DCHECK(character);
     beginDOCTYPE();
     m_data.push_back(character);
     m_orAllData |= character;
   }
 
   // FIXME: Distinguish between a missing public identifer and an empty one.
   const WTF::Vector<UChar>& publicIdentifier() const {
-    ASSERT(m_type == DOCTYPE);
+    DCHECK_EQ(m_type, DOCTYPE);
     return m_doctypeData->m_publicIdentifier;
   }
 
   // FIXME: Distinguish between a missing system identifer and an empty one.
   const WTF::Vector<UChar>& systemIdentifier() const {
-    ASSERT(m_type == DOCTYPE);
+    DCHECK_EQ(m_type, DOCTYPE);
     return m_doctypeData->m_systemIdentifier;
   }
 
   void setPublicIdentifierToEmptyString() {
-    ASSERT(m_type == DOCTYPE);
+    DCHECK_EQ(m_type, DOCTYPE);
     m_doctypeData->m_hasPublicIdentifier = true;
     m_doctypeData->m_publicIdentifier.clear();
   }
 
   void setSystemIdentifierToEmptyString() {
-    ASSERT(m_type == DOCTYPE);
+    DCHECK_EQ(m_type, DOCTYPE);
     m_doctypeData->m_hasSystemIdentifier = true;
     m_doctypeData->m_systemIdentifier.clear();
   }
 
   void appendToPublicIdentifier(UChar character) {
-    ASSERT(character);
-    ASSERT(m_type == DOCTYPE);
-    ASSERT(m_doctypeData->m_hasPublicIdentifier);
+    DCHECK(character);
+    DCHECK_EQ(m_type, DOCTYPE);
+    DCHECK(m_doctypeData->m_hasPublicIdentifier);
     m_doctypeData->m_publicIdentifier.push_back(character);
   }
 
   void appendToSystemIdentifier(UChar character) {
-    ASSERT(character);
-    ASSERT(m_type == DOCTYPE);
-    ASSERT(m_doctypeData->m_hasSystemIdentifier);
+    DCHECK(character);
+    DCHECK_EQ(m_type, DOCTYPE);
+    DCHECK(m_doctypeData->m_hasSystemIdentifier);
     m_doctypeData->m_systemIdentifier.push_back(character);
   }
 
   std::unique_ptr<DoctypeData> releaseDoctypeData() {
     return std::move(m_doctypeData);
   }
 
   /* Start/End Tag Tokens */
 
   bool selfClosing() const {
-    ASSERT(m_type == StartTag || m_type == EndTag);
+    DCHECK(m_type == StartTag || m_type == EndTag);
     return m_selfClosing;
   }
 
   void setSelfClosing() {
-    ASSERT(m_type == StartTag || m_type == EndTag);
+    DCHECK(m_type == StartTag || m_type == EndTag);
     m_selfClosing = true;
   }
 
   void beginStartTag(UChar character) {
-    ASSERT(character);
-    ASSERT(m_type == Uninitialized);
+    DCHECK(character);
+    DCHECK_EQ(m_type, Uninitialized);
     m_type = StartTag;
     m_selfClosing = false;
     m_currentAttribute = 0;
     m_attributes.clear();
 
     m_data.push_back(character);
     m_orAllData |= character;
   }
 
   void beginEndTag(LChar character) {
-    ASSERT(m_type == Uninitialized);
+    DCHECK_EQ(m_type, Uninitialized);
     m_type = EndTag;
     m_selfClosing = false;
     m_currentAttribute = 0;
     m_attributes.clear();
 
     m_data.push_back(character);
   }
 
   void beginEndTag(const Vector<LChar, 32>& characters) {
-    ASSERT(m_type == Uninitialized);
+    DCHECK_EQ(m_type, Uninitialized);
     m_type = EndTag;
     m_selfClosing = false;
     m_currentAttribute = 0;
     m_attributes.clear();
 
     m_data.appendVector(characters);
   }
 
   void addNewAttribute() {
-    ASSERT(m_type == StartTag || m_type == EndTag);
+    DCHECK(m_type == StartTag || m_type == EndTag);
     m_attributes.grow(m_attributes.size() + 1);
     m_currentAttribute = &m_attributes.back();
     m_currentAttribute->mutableNameRange().clear();
     m_currentAttribute->mutableValueRange().clear();
   }
 
   void beginAttributeName(int offset) {
     m_currentAttribute->mutableNameRange().start = offset - m_baseOffset;
     m_currentAttribute->nameRange().checkValidStart();
   }
@@ skipping 11 matching lines @@
     m_currentAttribute->mutableValueRange().start = offset - m_baseOffset;
     m_currentAttribute->valueRange().checkValidStart();
   }
 
   void endAttributeValue(int offset) {
     m_currentAttribute->mutableValueRange().end = offset - m_baseOffset;
     m_currentAttribute->valueRange().checkValid();
   }
 
   void appendToAttributeName(UChar character) {
-    ASSERT(character);
-    ASSERT(m_type == StartTag || m_type == EndTag);
+    DCHECK(character);
+    DCHECK(m_type == StartTag || m_type == EndTag);
     m_currentAttribute->nameRange().checkValidStart();
     m_currentAttribute->appendToName(character);
   }
 
   void appendToAttributeValue(UChar character) {
-    ASSERT(character);
-    ASSERT(m_type == StartTag || m_type == EndTag);
+    DCHECK(character);
+    DCHECK(m_type == StartTag || m_type == EndTag);
     m_currentAttribute->valueRange().checkValidStart();
     m_currentAttribute->appendToValue(character);
   }
 
   void appendToAttributeValue(size_t i, const String& value) {
-    ASSERT(!value.isEmpty());
-    ASSERT(m_type == StartTag || m_type == EndTag);
+    DCHECK(!value.isEmpty());
+    DCHECK(m_type == StartTag || m_type == EndTag);
     m_attributes[i].appendToValue(value);
   }
 
   const AttributeList& attributes() const {
-    ASSERT(m_type == StartTag || m_type == EndTag);
+    DCHECK(m_type == StartTag || m_type == EndTag);
     return m_attributes;
   }
 
   const Attribute* getAttributeItem(const QualifiedName& name) const {
     for (unsigned i = 0; i < m_attributes.size(); ++i) {
       if (m_attributes.at(i).name() == name.localName())
         return &m_attributes.at(i);
     }
     return 0;
   }
 
   // Used by the XSSAuditor to nuke XSS-laden attributes.
   void eraseValueOfAttribute(size_t i) {
-    ASSERT(m_type == StartTag || m_type == EndTag);
+    DCHECK(m_type == StartTag || m_type == EndTag);
     m_attributes[i].clearValue();
   }
 
   /* Character Tokens */
 
   // Starting a character token works slightly differently than starting
   // other types of tokens because we want to save a per-character branch.
   void ensureIsCharacterToken() {
-    ASSERT(m_type == Uninitialized || m_type == Character);
+    DCHECK(m_type == Uninitialized || m_type == Character);
     m_type = Character;
   }
 
   const DataVector& characters() const {
-    ASSERT(m_type == Character);
+    DCHECK_EQ(m_type, Character);
     return m_data;
   }
 
   void appendToCharacter(char character) {
-    ASSERT(m_type == Character);
+    DCHECK_EQ(m_type, Character);
     m_data.push_back(character);
   }
 
   void appendToCharacter(UChar character) {
-    ASSERT(m_type == Character);
+    DCHECK_EQ(m_type, Character);
     m_data.push_back(character);
     m_orAllData |= character;
   }
 
   void appendToCharacter(const Vector<LChar, 32>& characters) {
-    ASSERT(m_type == Character);
+    DCHECK_EQ(m_type, Character);
     m_data.appendVector(characters);
   }
 
   /* Comment Tokens */
 
   const DataVector& comment() const {
-    ASSERT(m_type == Comment);
+    DCHECK_EQ(m_type, Comment);
     return m_data;
   }
 
   void beginComment() {
-    ASSERT(m_type == Uninitialized);
+    DCHECK_EQ(m_type, Uninitialized);
     m_type = Comment;
   }
 
   void appendToComment(UChar character) {
-    ASSERT(character);
-    ASSERT(m_type == Comment);
+    DCHECK(character);
+    DCHECK_EQ(m_type, Comment);
     m_data.push_back(character);
     m_orAllData |= character;
   }
 
   // Only for XSSAuditor
   void eraseCharacters() {
-    ASSERT(m_type == Character);
+    DCHECK_EQ(m_type, Character);
     m_data.clear();
     m_orAllData = 0;
   }
 
  private:
   TokenType m_type;
   Attribute::Range m_range;  // Always starts at zero.
   int m_baseOffset;
   DataVector m_data;
   UChar m_orAllData;
 
   // For StartTag and EndTag
   bool m_selfClosing;
   AttributeList m_attributes;
 
   // A pointer into m_attributes used during lexing.
   Attribute* m_currentAttribute;
 
   // For DOCTYPE
   std::unique_ptr<DoctypeData> m_doctypeData;
 };
 
 #ifndef NDEBUG
 const char* toString(HTMLToken::TokenType);
 #endif
 
 }  // namespace blink
 
 #endif