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

third_party/WebKit/Source/core/html/parser/AtomicHTMLToken.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 24 matching lines @@
 #include <memory>
 
 namespace blink {
 
 class CORE_EXPORT AtomicHTMLToken {
   STACK_ALLOCATED();
   WTF_MAKE_NONCOPYABLE(AtomicHTMLToken);
 
  public:
   bool forceQuirks() const {
-    ASSERT(m_type == HTMLToken::DOCTYPE);
+    DCHECK_EQ(m_type, HTMLToken::DOCTYPE);
     return m_doctypeData->m_forceQuirks;
   }
 
   HTMLToken::TokenType type() const { return m_type; }
 
   const AtomicString& name() const {
-    ASSERT(usesName());
+    DCHECK(usesName());
     return m_name;
   }
 
   void setName(const AtomicString& name) {
-    ASSERT(usesName());
+    DCHECK(usesName());
     m_name = name;
   }
 
   bool selfClosing() const {
-    ASSERT(m_type == HTMLToken::StartTag || m_type == HTMLToken::EndTag);
+    DCHECK(m_type == HTMLToken::StartTag || m_type == HTMLToken::EndTag);
     return m_selfClosing;
   }
 
   Attribute* getAttributeItem(const QualifiedName& attributeName) {
-    ASSERT(usesAttributes());
+    DCHECK(usesAttributes());
     return findAttributeInVector(m_attributes, attributeName);
   }
 
   Vector<Attribute>& attributes() {
-    ASSERT(usesAttributes());
+    DCHECK(usesAttributes());
     return m_attributes;
   }
 
   const Vector<Attribute>& attributes() const {
-    ASSERT(usesAttributes());
+    DCHECK(usesAttributes());
     return m_attributes;
   }
 
   const String& characters() const {
-    ASSERT(m_type == HTMLToken::Character);
+    DCHECK_EQ(m_type, HTMLToken::Character);
     return m_data;
   }
 
   const String& comment() const {
-    ASSERT(m_type == HTMLToken::Comment);
+    DCHECK_EQ(m_type, HTMLToken::Comment);
     return m_data;
   }
 
   // FIXME: Distinguish between a missing public identifer and an empty one.
   Vector<UChar>& publicIdentifier() const {
-    ASSERT(m_type == HTMLToken::DOCTYPE);
+    DCHECK_EQ(m_type, HTMLToken::DOCTYPE);
     return m_doctypeData->m_publicIdentifier;
   }
 
   // FIXME: Distinguish between a missing system identifer and an empty one.
   Vector<UChar>& systemIdentifier() const {
-    ASSERT(m_type == HTMLToken::DOCTYPE);
+    DCHECK_EQ(m_type, HTMLToken::DOCTYPE);
     return m_doctypeData->m_systemIdentifier;
   }
 
   explicit AtomicHTMLToken(HTMLToken& token) : m_type(token.type()) {
     switch (m_type) {
       case HTMLToken::Uninitialized:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         break;
       case HTMLToken::DOCTYPE:
         m_name = AtomicString(token.name());
         m_doctypeData = token.releaseDoctypeData();
         break;
       case HTMLToken::EndOfFile:
         break;
       case HTMLToken::StartTag:
       case HTMLToken::EndTag: {
         m_selfClosing = token.selfClosing();
@@ skipping 12 matching lines @@
         else
           m_data = String(token.data());
         break;
     }
   }
 
   explicit AtomicHTMLToken(const CompactHTMLToken& token)
       : m_type(token.type()) {
     switch (m_type) {
       case HTMLToken::Uninitialized:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         break;
       case HTMLToken::DOCTYPE:
         m_name = AtomicString(token.data());
         m_doctypeData = WTF::makeUnique<DoctypeData>();
         m_doctypeData->m_hasPublicIdentifier = true;
         token.publicIdentifier().appendTo(m_doctypeData->m_publicIdentifier);
         m_doctypeData->m_hasSystemIdentifier = true;
         token.systemIdentifier().appendTo(m_doctypeData->m_systemIdentifier);
         m_doctypeData->m_forceQuirks = token.doctypeForcesQuirks();
         break;
@@ skipping 25 matching lines @@
   explicit AtomicHTMLToken(HTMLToken::TokenType type)
       : m_type(type), m_selfClosing(false) {}
 
   AtomicHTMLToken(HTMLToken::TokenType type,
                   const AtomicString& name,
                   const Vector<Attribute>& attributes = Vector<Attribute>())
       : m_type(type),
         m_name(name),
         m_selfClosing(false),
         m_attributes(attributes) {
-    ASSERT(usesName());
+    DCHECK(usesName());
   }
 
 #ifndef NDEBUG
   void show() const;
 #endif
 
  private:
   HTMLToken::TokenType m_type;
 
   void initializeAttributes(const HTMLToken::AttributeList& attributes);
@@ skipping 37 matching lines @@
     const QualifiedName& name = nameForAttribute(attribute);
     // FIXME: This is N^2 for the number of attributes.
     if (!findAttributeInVector(m_attributes, name))
       m_attributes.push_back(Attribute(name, value));
   }
 }
 
 }  // namespace blink
 
 #endif