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

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

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  * Copyright (C) 2011, 2014 Apple 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
@@ skipping 98 matching lines @@
 }
 
 class HTMLTreeBuilder::CharacterTokenBuffer {
   WTF_MAKE_NONCOPYABLE(CharacterTokenBuffer);
 
  public:
   explicit CharacterTokenBuffer(AtomicHTMLToken* token)
       : m_characters(token->characters().impl()),
         m_current(0),
         m_end(token->characters().length()) {
-    ASSERT(!isEmpty());
+    DCHECK(!isEmpty());
   }
 
   explicit CharacterTokenBuffer(const String& characters)
       : m_characters(characters.impl()),
         m_current(0),
         m_end(characters.length()) {
-    ASSERT(!isEmpty());
+    DCHECK(!isEmpty());
   }
 
-  ~CharacterTokenBuffer() { ASSERT(isEmpty()); }
+  ~CharacterTokenBuffer() { DCHECK(isEmpty()); }
 
   bool isEmpty() const { return m_current == m_end; }
 
   void skipAtMostOneLeadingNewline() {
-    ASSERT(!isEmpty());
+    DCHECK(!isEmpty());
     if ((*m_characters)[m_current] == '\n')
       ++m_current;
   }
 
   void skipLeadingWhitespace() { skipLeading<isHTMLSpace<UChar>>(); }
 
   StringView takeLeadingWhitespace() {
     return takeLeading<isHTMLSpace<UChar>>();
   }
 
   void skipLeadingNonWhitespace() { skipLeading<isNotHTMLSpace<UChar>>(); }
 
   void skipRemaining() { m_current = m_end; }
 
   StringView takeRemaining() {
-    ASSERT(!isEmpty());
+    DCHECK(!isEmpty());
     unsigned start = m_current;
     m_current = m_end;
     return StringView(m_characters.get(), start, m_end - start);
   }
 
   void giveRemainingTo(StringBuilder& recipient) {
     if (m_characters->is8Bit())
       recipient.append(m_characters->characters8() + m_current,
                        m_end - m_current);
     else
       recipient.append(m_characters->characters16() + m_current,
                        m_end - m_current);
     m_current = m_end;
   }
 
   String takeRemainingWhitespace() {
-    ASSERT(!isEmpty());
+    DCHECK(!isEmpty());
     const unsigned start = m_current;
     m_current = m_end;  // One way or another, we're taking everything!
 
     unsigned length = 0;
     for (unsigned i = start; i < m_end; ++i) {
       if (isHTMLSpace<UChar>((*m_characters)[i]))
         ++length;
     }
     // Returning the null string when there aren't any whitespace
     // characters is slightly cleaner semantically because we don't want
@@ skipping 10 matching lines @@
       if (isHTMLSpace<UChar>(c))
         result.append(c);
     }
 
     return result.toString();
   }
 
  private:
   template <bool characterPredicate(UChar)>
   void skipLeading() {
-    ASSERT(!isEmpty());
+    DCHECK(!isEmpty());
     while (characterPredicate((*m_characters)[m_current])) {
       if (++m_current == m_end)
         return;
     }
   }
 
   template <bool characterPredicate(UChar)>
   StringView takeLeading() {
-    ASSERT(!isEmpty());
+    DCHECK(!isEmpty());
     const unsigned start = m_current;
     skipLeading<characterPredicate>();
     return StringView(m_characters.get(), start, m_current - start);
   }
 
   RefPtr<StringImpl> m_characters;
   unsigned m_current;
   unsigned m_end;
 };
 
@@ skipping 13 matching lines @@
 
 HTMLTreeBuilder::HTMLTreeBuilder(HTMLDocumentParser* parser,
                                  DocumentFragment* fragment,
                                  Element* contextElement,
                                  ParserContentPolicy parserContentPolicy,
                                  const HTMLParserOptions& options)
     : HTMLTreeBuilder(parser,
                       fragment->document(),
                       parserContentPolicy,
                       options) {
-  ASSERT(isMainThread());
-  ASSERT(contextElement);
+  DCHECK(isMainThread());
+  DCHECK(contextElement);
   m_tree.initFragmentParsing(fragment, contextElement);
   m_fragmentContext.init(fragment, contextElement);
 
   // Steps 4.2-4.6 of the HTML5 Fragment Case parsing algorithm:
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#fragment-case
   // For efficiency, we skip step 4.2 ("Let root be a new html element with no
   // attributes") and instead use the DocumentFragment as a root node.
   m_tree.openElements()->pushRootNode(HTMLStackItem::create(
       fragment, HTMLStackItem::ItemForDocumentFragmentNode));
 
@@ skipping 32 matching lines @@
   // DocumentParser expects detach() to always be called before it's destroyed.
   m_isAttached = false;
 #endif
   // HTMLConstructionSite might be on the callstack when detach() is called
   // otherwise we'd just call m_tree.clear() here instead.
   m_tree.detach();
 }
 
 Element* HTMLTreeBuilder::takeScriptToProcess(
     TextPosition& scriptStartPosition) {
-  ASSERT(m_scriptToProcess);
-  ASSERT(!m_tree.hasPendingTasks());
+  DCHECK(m_scriptToProcess);
+  DCHECK(!m_tree.hasPendingTasks());
   // Unpause ourselves, callers may pause us again when processing the script.
   // The HTML5 spec is written as though scripts are executed inside the tree
   // builder.  We pause the parser to exit the tree builder, and then resume
   // before running scripts.
   scriptStartPosition = m_scriptToProcessStartPosition;
   m_scriptToProcessStartPosition = uninitializedPositionValue1();
   return m_scriptToProcess.release();
 }
 
 void HTMLTreeBuilder::constructTree(AtomicHTMLToken* token) {
@@ skipping 29 matching lines @@
 
   // Any non-character token needs to cause us to flush any pending text
   // immediately. NOTE: flush() can cause any queued tasks to execute, possibly
   // re-entering the parser.
   m_tree.flush(FlushAlways);
   m_shouldSkipLeadingNewline = false;
 
   switch (token->type()) {
     case HTMLToken::Uninitialized:
     case HTMLToken::Character:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       break;
     case HTMLToken::DOCTYPE:
       processDoctypeToken(token);
       break;
     case HTMLToken::StartTag:
       processStartTag(token);
       break;
     case HTMLToken::EndTag:
       processEndTag(token);
       break;
     case HTMLToken::Comment:
       processComment(token);
       break;
     case HTMLToken::EndOfFile:
       processEndOfFile(token);
       break;
   }
 }
 
 void HTMLTreeBuilder::processDoctypeToken(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::DOCTYPE);
+  DCHECK_EQ(token->type(), HTMLToken::DOCTYPE);
   if (m_insertionMode == InitialMode) {
     m_tree.insertDoctype(token);
     setInsertionMode(BeforeHTMLMode);
     return;
   }
   if (m_insertionMode == InTableTextMode) {
     defaultForInTableText();
     processDoctypeToken(token);
     return;
   }
@@ skipping 40 matching lines @@
 }  // namespace
 
 template <bool shouldClose(const HTMLStackItem*)>
 void HTMLTreeBuilder::processCloseWhenNestedTag(AtomicHTMLToken* token) {
   m_framesetOk = false;
   HTMLElementStack::ElementRecord* nodeRecord =
       m_tree.openElements()->topRecord();
   while (1) {
     HTMLStackItem* item = nodeRecord->stackItem();
     if (shouldClose(item)) {
-      ASSERT(item->isElementNode());
+      DCHECK(item->isElementNode());
       processFakeEndTag(item->localName());
       break;
     }
     if (item->isSpecialNode() && !item->hasTagName(addressTag) &&
         !item->hasTagName(divTag) && !item->hasTagName(pTag))
       break;
     nodeRecord = nodeRecord->next();
   }
   processFakePEndTagIfPInButtonScope();
   m_tree.insertHTMLElement(token);
@@ skipping 87 matching lines @@
 
   for (unsigned i = 0; i < token->attributes().size(); ++i) {
     Attribute& tokenAttribute = token->attributes().at(i);
     const QualifiedName& name = map->at(tokenAttribute.localName());
     if (!name.localName().isNull())
       tokenAttribute.parserSetName(name);
   }
 }
 
 void HTMLTreeBuilder::processStartTagForInBody(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::StartTag);
+  DCHECK_EQ(token->type(), HTMLToken::StartTag);
   if (token->name() == htmlTag) {
     processHtmlStartTagForInBody(token);
     return;
   }
   if (token->name() == baseTag || token->name() == basefontTag ||
       token->name() == bgsoundTag || token->name() == commandTag ||
       token->name() == linkTag || token->name() == metaTag ||
       token->name() == noframesTag || token->name() == scriptTag ||
       token->name() == styleTag || token->name() == titleTag) {
     bool didProcess = processStartTagForInHead(token);
     DCHECK(didProcess);
     return;
   }
   if (token->name() == bodyTag) {
     parseError(token);
     if (!m_tree.openElements()->secondElementIsHTMLBodyElement() ||
         m_tree.openElements()->hasOnlyOneElement() ||
         m_tree.openElements()->hasTemplateInHTMLScope()) {
-      ASSERT(isParsingFragmentOrTemplateContents());
+      DCHECK(isParsingFragmentOrTemplateContents());
       return;
     }
     m_framesetOk = false;
     m_tree.insertHTMLBodyStartTagInBody(token);
     return;
   }
   if (token->name() == framesetTag) {
     parseError(token);
     if (!m_tree.openElements()->secondElementIsHTMLBodyElement() ||
         m_tree.openElements()->hasOnlyOneElement()) {
-      ASSERT(isParsingFragmentOrTemplateContents());
+      DCHECK(isParsingFragmentOrTemplateContents());
       return;
     }
     if (!m_framesetOk)
       return;
     m_tree.openElements()->bodyElement()->remove(ASSERT_NO_EXCEPTION);
     m_tree.openElements()->popUntil(m_tree.openElements()->bodyElement());
     m_tree.openElements()->popHTMLBodyElement();
 
     // Note: in the fragment case the root is a DocumentFragment instead of
     // a proper html element which is a quirk in Blink's implementation.
@@ skipping 269 matching lines @@
 
 void HTMLTreeBuilder::processTemplateStartTag(AtomicHTMLToken* token) {
   m_tree.activeFormattingElements()->appendMarker();
   m_tree.insertHTMLElement(token);
   m_framesetOk = false;
   m_templateInsertionModes.push_back(TemplateContentsMode);
   setInsertionMode(TemplateContentsMode);
 }
 
 bool HTMLTreeBuilder::processTemplateEndTag(AtomicHTMLToken* token) {
-  ASSERT(token->name() == templateTag.localName());
+  DCHECK_EQ(token->name(), templateTag.localName());
   if (!m_tree.openElements()->hasTemplateInHTMLScope()) {
-    ASSERT(m_templateInsertionModes.isEmpty() ||
+    DCHECK(m_templateInsertionModes.isEmpty() ||
            (m_templateInsertionModes.size() == 1 &&
             isHTMLTemplateElement(m_fragmentContext.contextElement())));
     parseError(token);
     return false;
   }
   m_tree.generateImpliedEndTags();
   if (!m_tree.currentStackItem()->hasTagName(templateTag))
     parseError(token);
   m_tree.openElements()->popUntilPopped(templateTag);
   m_tree.activeFormattingElements()->clearToLastMarker();
   m_templateInsertionModes.pop_back();
   resetInsertionModeAppropriately();
   return true;
 }
 
 bool HTMLTreeBuilder::processEndOfFileForInTemplateContents(
     AtomicHTMLToken* token) {
   AtomicHTMLToken endTemplate(HTMLToken::EndTag, templateTag.localName());
   if (!processTemplateEndTag(&endTemplate))
     return false;
 
   processEndOfFile(token);
   return true;
 }
 
 bool HTMLTreeBuilder::processColgroupEndTagForInColumnGroup() {
   if (m_tree.currentIsRootNode() ||
       isHTMLTemplateElement(*m_tree.currentNode())) {
-    ASSERT(isParsingFragmentOrTemplateContents());
+    DCHECK(isParsingFragmentOrTemplateContents());
     // FIXME: parse error
     return false;
   }
   m_tree.openElements()->pop();
   setInsertionMode(InTableMode);
   return true;
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/#adjusted-current-node
 HTMLStackItem* HTMLTreeBuilder::adjustedCurrentStackItem() const {
-  ASSERT(!m_tree.isEmpty());
+  DCHECK(!m_tree.isEmpty());
   if (isParsingFragment() && m_tree.openElements()->hasOnlyOneElement())
     return m_fragmentContext.contextElementStackItem();
 
   return m_tree.currentStackItem();
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#close-the-cell
 void HTMLTreeBuilder::closeTheCell() {
-  ASSERT(getInsertionMode() == InCellMode);
+  DCHECK_EQ(getInsertionMode(), InCellMode);
   if (m_tree.openElements()->inTableScope(tdTag)) {
-    ASSERT(!m_tree.openElements()->inTableScope(thTag));
+    DCHECK(!m_tree.openElements()->inTableScope(thTag));
     processFakeEndTag(tdTag);
     return;
   }
-  ASSERT(m_tree.openElements()->inTableScope(thTag));
+  DCHECK(m_tree.openElements()->inTableScope(thTag));
   processFakeEndTag(thTag);
-  ASSERT(getInsertionMode() == InRowMode);
+  DCHECK_EQ(getInsertionMode(), InRowMode);
 }
 
 void HTMLTreeBuilder::processStartTagForInTable(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::StartTag);
+  DCHECK_EQ(token->type(), HTMLToken::StartTag);
   if (token->name() == captionTag) {
     m_tree.openElements()->popUntilTableScopeMarker();
     m_tree.activeFormattingElements()->appendMarker();
     m_tree.insertHTMLElement(token);
     setInsertionMode(InCaptionMode);
     return;
   }
   if (token->name() == colgroupTag) {
     m_tree.openElements()->popUntilTableScopeMarker();
     m_tree.insertHTMLElement(token);
     setInsertionMode(InColumnGroupMode);
     return;
   }
   if (token->name() == colTag) {
     processFakeStartTag(colgroupTag);
-    ASSERT(InColumnGroupMode);
+    DCHECK(InColumnGroupMode);
     processStartTag(token);
     return;
   }
   if (isTableBodyContextTag(token->name())) {
     m_tree.openElements()->popUntilTableScopeMarker();
     m_tree.insertHTMLElement(token);
     setInsertionMode(InTableBodyMode);
     return;
   }
   if (isTableCellContextTag(token->name()) || token->name() == trTag) {
     processFakeStartTag(tbodyTag);
-    ASSERT(getInsertionMode() == InTableBodyMode);
+    DCHECK_EQ(getInsertionMode(), InTableBodyMode);
     processStartTag(token);
     return;
   }
   if (token->name() == tableTag) {
     parseError(token);
     if (!processTableEndTagForInTable()) {
-      ASSERT(isParsingFragmentOrTemplateContents());
+      DCHECK(isParsingFragmentOrTemplateContents());
       return;
     }
     processStartTag(token);
     return;
   }
   if (token->name() == styleTag || token->name() == scriptTag) {
     processStartTagForInHead(token);
     return;
   }
   if (token->name() == inputTag) {
@@ skipping 16 matching lines @@
   if (token->name() == templateTag) {
     processTemplateStartTag(token);
     return;
   }
   parseError(token);
   HTMLConstructionSite::RedirectToFosterParentGuard redirecter(m_tree);
   processStartTagForInBody(token);
 }
 
 void HTMLTreeBuilder::processStartTag(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::StartTag);
+  DCHECK_EQ(token->type(), HTMLToken::StartTag);
   switch (getInsertionMode()) {
     case InitialMode:
-      ASSERT(getInsertionMode() == InitialMode);
+      DCHECK_EQ(getInsertionMode(), InitialMode);
       defaultForInitial();
     // Fall through.
     case BeforeHTMLMode:
-      ASSERT(getInsertionMode() == BeforeHTMLMode);
+      DCHECK_EQ(getInsertionMode(), BeforeHTMLMode);
       if (token->name() == htmlTag) {
         m_tree.insertHTMLHtmlStartTagBeforeHTML(token);
         setInsertionMode(BeforeHeadMode);
         return;
       }
       defaultForBeforeHTML();
     // Fall through.
     case BeforeHeadMode:
-      ASSERT(getInsertionMode() == BeforeHeadMode);
+      DCHECK_EQ(getInsertionMode(), BeforeHeadMode);
       if (token->name() == htmlTag) {
         processHtmlStartTagForInBody(token);
         return;
       }
       if (token->name() == headTag) {
         m_tree.insertHTMLHeadElement(token);
         setInsertionMode(InHeadMode);
         return;
       }
       defaultForBeforeHead();
     // Fall through.
     case InHeadMode:
-      ASSERT(getInsertionMode() == InHeadMode);
+      DCHECK_EQ(getInsertionMode(), InHeadMode);
       if (processStartTagForInHead(token))
         return;
       defaultForInHead();
     // Fall through.
     case AfterHeadMode:
-      ASSERT(getInsertionMode() == AfterHeadMode);
+      DCHECK_EQ(getInsertionMode(), AfterHeadMode);
       if (token->name() == htmlTag) {
         processHtmlStartTagForInBody(token);
         return;
       }
       if (token->name() == bodyTag) {
         m_framesetOk = false;
         m_tree.insertHTMLBodyElement(token);
         setInsertionMode(InBodyMode);
         return;
       }
       if (token->name() == framesetTag) {
         m_tree.insertHTMLElement(token);
         setInsertionMode(InFramesetMode);
         return;
       }
       if (token->name() == baseTag || token->name() == basefontTag ||
           token->name() == bgsoundTag || token->name() == linkTag ||
           token->name() == metaTag || token->name() == noframesTag ||
           token->name() == scriptTag || token->name() == styleTag ||
           token->name() == templateTag || token->name() == titleTag) {
         parseError(token);
-        ASSERT(m_tree.head());
+        DCHECK(m_tree.head());
         m_tree.openElements()->pushHTMLHeadElement(m_tree.headStackItem());
         processStartTagForInHead(token);
         m_tree.openElements()->removeHTMLHeadElement(m_tree.head());
         return;
       }
       if (token->name() == headTag) {
         parseError(token);
         return;
       }
       defaultForAfterHead();
     // Fall through
     case InBodyMode:
-      ASSERT(getInsertionMode() == InBodyMode);
+      DCHECK_EQ(getInsertionMode(), InBodyMode);
       processStartTagForInBody(token);
       break;
     case InTableMode:
-      ASSERT(getInsertionMode() == InTableMode);
+      DCHECK_EQ(getInsertionMode(), InTableMode);
       processStartTagForInTable(token);
       break;
     case InCaptionMode:
-      ASSERT(getInsertionMode() == InCaptionMode);
+      DCHECK_EQ(getInsertionMode(), InCaptionMode);
       if (isCaptionColOrColgroupTag(token->name()) ||
           isTableBodyContextTag(token->name()) ||
           isTableCellContextTag(token->name()) || token->name() == trTag) {
         parseError(token);
         if (!processCaptionEndTagForInCaption()) {
-          ASSERT(isParsingFragment());
+          DCHECK(isParsingFragment());
           return;
         }
         processStartTag(token);
         return;
       }
       processStartTagForInBody(token);
       break;
     case InColumnGroupMode:
-      ASSERT(getInsertionMode() == InColumnGroupMode);
+      DCHECK_EQ(getInsertionMode(), InColumnGroupMode);
       if (token->name() == htmlTag) {
         processHtmlStartTagForInBody(token);
         return;
       }
       if (token->name() == colTag) {
         m_tree.insertSelfClosingHTMLElementDestroyingToken(token);
         return;
       }
       if (token->name() == templateTag) {
         processTemplateStartTag(token);
         return;
       }
       if (!processColgroupEndTagForInColumnGroup()) {
-        ASSERT(isParsingFragmentOrTemplateContents());
+        DCHECK(isParsingFragmentOrTemplateContents());
         return;
       }
       processStartTag(token);
       break;
     case InTableBodyMode:
-      ASSERT(getInsertionMode() == InTableBodyMode);
+      DCHECK_EQ(getInsertionMode(), InTableBodyMode);
       if (token->name() == trTag) {
         // How is there ever anything to pop?
         m_tree.openElements()->popUntilTableBodyScopeMarker();
         m_tree.insertHTMLElement(token);
         setInsertionMode(InRowMode);
         return;
       }
       if (isTableCellContextTag(token->name())) {
         parseError(token);
         processFakeStartTag(trTag);
-        ASSERT(getInsertionMode() == InRowMode);
+        DCHECK_EQ(getInsertionMode(), InRowMode);
         processStartTag(token);
         return;
       }
       if (isCaptionColOrColgroupTag(token->name()) ||
           isTableBodyContextTag(token->name())) {
         // FIXME: This is slow.
         if (!m_tree.openElements()->inTableScope(tbodyTag) &&
             !m_tree.openElements()->inTableScope(theadTag) &&
             !m_tree.openElements()->inTableScope(tfootTag)) {
-          ASSERT(isParsingFragmentOrTemplateContents());
+          DCHECK(isParsingFragmentOrTemplateContents());
           parseError(token);
           return;
         }
         m_tree.openElements()->popUntilTableBodyScopeMarker();
-        ASSERT(isTableBodyContextTag(m_tree.currentStackItem()->localName()));
+        DCHECK(isTableBodyContextTag(m_tree.currentStackItem()->localName()));
         processFakeEndTag(m_tree.currentStackItem()->localName());
         processStartTag(token);
         return;
       }
       processStartTagForInTable(token);
       break;
     case InRowMode:
-      ASSERT(getInsertionMode() == InRowMode);
+      DCHECK_EQ(getInsertionMode(), InRowMode);
       if (isTableCellContextTag(token->name())) {
         m_tree.openElements()->popUntilTableRowScopeMarker();
         m_tree.insertHTMLElement(token);
         setInsertionMode(InCellMode);
         m_tree.activeFormattingElements()->appendMarker();
         return;
       }
       if (token->name() == trTag || isCaptionColOrColgroupTag(token->name()) ||
           isTableBodyContextTag(token->name())) {
         if (!processTrEndTagForInRow()) {
-          ASSERT(isParsingFragmentOrTemplateContents());
+          DCHECK(isParsingFragmentOrTemplateContents());
           return;
         }
-        ASSERT(getInsertionMode() == InTableBodyMode);
+        DCHECK_EQ(getInsertionMode(), InTableBodyMode);
         processStartTag(token);
         return;
       }
       processStartTagForInTable(token);
       break;
     case InCellMode:
-      ASSERT(getInsertionMode() == InCellMode);
+      DCHECK_EQ(getInsertionMode(), InCellMode);
       if (isCaptionColOrColgroupTag(token->name()) ||
           isTableCellContextTag(token->name()) || token->name() == trTag ||
           isTableBodyContextTag(token->name())) {
         // FIXME: This could be more efficient.
         if (!m_tree.openElements()->inTableScope(tdTag) &&
             !m_tree.openElements()->inTableScope(thTag)) {
-          ASSERT(isParsingFragment());
+          DCHECK(isParsingFragment());
           parseError(token);
           return;
         }
         closeTheCell();
         processStartTag(token);
         return;
       }
       processStartTagForInBody(token);
       break;
     case AfterBodyMode:
     case AfterAfterBodyMode:
-      ASSERT(getInsertionMode() == AfterBodyMode ||
+      DCHECK(getInsertionMode() == AfterBodyMode ||
              getInsertionMode() == AfterAfterBodyMode);
       if (token->name() == htmlTag) {
         processHtmlStartTagForInBody(token);
         return;
       }
       setInsertionMode(InBodyMode);
       processStartTag(token);
       break;
     case InHeadNoscriptMode:
-      ASSERT(getInsertionMode() == InHeadNoscriptMode);
+      DCHECK_EQ(getInsertionMode(), InHeadNoscriptMode);
       if (token->name() == htmlTag) {
         processHtmlStartTagForInBody(token);
         return;
       }
       if (token->name() == basefontTag || token->name() == bgsoundTag ||
           token->name() == linkTag || token->name() == metaTag ||
           token->name() == noframesTag || token->name() == styleTag) {
         bool didProcess = processStartTagForInHead(token);
         DCHECK(didProcess);
         return;
       }
       if (token->name() == htmlTag || token->name() == noscriptTag) {
         parseError(token);
         return;
       }
       defaultForInHeadNoscript();
       processToken(token);
       break;
     case InFramesetMode:
-      ASSERT(getInsertionMode() == InFramesetMode);
+      DCHECK_EQ(getInsertionMode(), InFramesetMode);
       if (token->name() == htmlTag) {
         processHtmlStartTagForInBody(token);
         return;
       }
       if (token->name() == framesetTag) {
         m_tree.insertHTMLElement(token);
         return;
       }
       if (token->name() == frameTag) {
         m_tree.insertSelfClosingHTMLElementDestroyingToken(token);
         return;
       }
       if (token->name() == noframesTag) {
         processStartTagForInHead(token);
         return;
       }
       if (token->name() == templateTag) {
         processTemplateStartTag(token);
         return;
       }
       parseError(token);
       break;
     case AfterFramesetMode:
     case AfterAfterFramesetMode:
-      ASSERT(getInsertionMode() == AfterFramesetMode ||
+      DCHECK(getInsertionMode() == AfterFramesetMode ||
              getInsertionMode() == AfterAfterFramesetMode);
       if (token->name() == htmlTag) {
         processHtmlStartTagForInBody(token);
         return;
       }
       if (token->name() == noframesTag) {
         processStartTagForInHead(token);
         return;
       }
       parseError(token);
       break;
     case InSelectInTableMode:
-      ASSERT(getInsertionMode() == InSelectInTableMode);
+      DCHECK_EQ(getInsertionMode(), InSelectInTableMode);
       if (token->name() == captionTag || token->name() == tableTag ||
           isTableBodyContextTag(token->name()) || token->name() == trTag ||
           isTableCellContextTag(token->name())) {
         parseError(token);
         AtomicHTMLToken endSelect(HTMLToken::EndTag, selectTag.localName());
         processEndTag(&endSelect);
         processStartTag(token);
         return;
       }
     // Fall through
     case InSelectMode:
-      ASSERT(getInsertionMode() == InSelectMode ||
+      DCHECK(getInsertionMode() == InSelectMode ||
              getInsertionMode() == InSelectInTableMode);
       if (token->name() == htmlTag) {
         processHtmlStartTagForInBody(token);
         return;
       }
       if (token->name() == optionTag) {
         if (m_tree.currentStackItem()->hasTagName(optionTag)) {
           AtomicHTMLToken endOption(HTMLToken::EndTag, optionTag.localName());
           processEndTag(&endOption);
         }
@@ skipping 16 matching lines @@
       if (token->name() == selectTag) {
         parseError(token);
         AtomicHTMLToken endSelect(HTMLToken::EndTag, selectTag.localName());
         processEndTag(&endSelect);
         return;
       }
       if (token->name() == inputTag || token->name() == keygenTag ||
           token->name() == textareaTag) {
         parseError(token);
         if (!m_tree.openElements()->inSelectScope(selectTag)) {
-          ASSERT(isParsingFragment());
+          DCHECK(isParsingFragment());
           return;
         }
         AtomicHTMLToken endSelect(HTMLToken::EndTag, selectTag.localName());
         processEndTag(&endSelect);
         processStartTag(token);
         return;
       }
       if (token->name() == scriptTag) {
         bool didProcess = processStartTagForInHead(token);
         DCHECK(didProcess);
         return;
       }
       if (token->name() == templateTag) {
         processTemplateStartTag(token);
         return;
       }
       break;
     case InTableTextMode:
       defaultForInTableText();
       processStartTag(token);
       break;
     case TextMode:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       break;
     case TemplateContentsMode:
       if (token->name() == templateTag) {
         processTemplateStartTag(token);
         return;
       }
 
       if (token->name() == linkTag || token->name() == scriptTag ||
           token->name() == styleTag || token->name() == metaTag) {
         processStartTagForInHead(token);
         return;
       }
 
       InsertionMode insertionMode = TemplateContentsMode;
       if (token->name() == frameTag)
         insertionMode = InFramesetMode;
       else if (token->name() == colTag)
         insertionMode = InColumnGroupMode;
       else if (isCaptionColOrColgroupTag(token->name()) ||
                isTableBodyContextTag(token->name()))
         insertionMode = InTableMode;
       else if (token->name() == trTag)
         insertionMode = InTableBodyMode;
       else if (isTableCellContextTag(token->name()))
         insertionMode = InRowMode;
       else
         insertionMode = InBodyMode;
 
-      ASSERT(insertionMode != TemplateContentsMode);
-      ASSERT(m_templateInsertionModes.back() == TemplateContentsMode);
+      DCHECK_NE(insertionMode, TemplateContentsMode);
+      DCHECK_EQ(m_templateInsertionModes.back(), TemplateContentsMode);
       m_templateInsertionModes.back() = insertionMode;
       setInsertionMode(insertionMode);
 
       processStartTag(token);
       break;
   }
 }
 
 void HTMLTreeBuilder::processHtmlStartTagForInBody(AtomicHTMLToken* token) {
   parseError(token);
   if (m_tree.openElements()->hasTemplateInHTMLScope()) {
-    ASSERT(isParsingTemplateContents());
+    DCHECK(isParsingTemplateContents());
     return;
   }
   m_tree.insertHTMLHtmlStartTagInBody(token);
 }
 
 bool HTMLTreeBuilder::processBodyEndTagForInBody(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::EndTag);
-  ASSERT(token->name() == bodyTag);
+  DCHECK_EQ(token->type(), HTMLToken::EndTag);
+  DCHECK(token->name() == bodyTag);
   if (!m_tree.openElements()->inScope(bodyTag.localName())) {
     parseError(token);
     return false;
   }
   // Emit a more specific parse error based on stack contents.
   DVLOG(1) << "Not implmeneted.";
   setInsertionMode(AfterBodyMode);
   return true;
 }
 
 void HTMLTreeBuilder::processAnyOtherEndTagForInBody(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::EndTag);
+  DCHECK_EQ(token->type(), HTMLToken::EndTag);
   if (token->name() == menuitemTag)
     UseCounter::count(m_tree.currentNode()->document(),
                       UseCounter::MenuItemCloseTag);
   HTMLElementStack::ElementRecord* record = m_tree.openElements()->topRecord();
   while (1) {
     HTMLStackItem* item = record->stackItem();
     if (item->matchesHTMLTag(token->name())) {
       m_tree.generateImpliedEndTagsWithExclusion(token->name());
       if (!m_tree.currentStackItem()->matchesHTMLTag(token->name()))
         parseError(token);
@@ skipping 49 matching lines @@
     HTMLElementStack::ElementRecord* furthestBlock =
         m_tree.openElements()->furthestBlockForFormattingElement(
             formattingElement);
     // 6.
     if (!furthestBlock) {
       m_tree.openElements()->popUntilPopped(formattingElement);
       m_tree.activeFormattingElements()->remove(formattingElement);
       return;
     }
     // 7.
-    ASSERT(furthestBlock->isAbove(formattingElementRecord));
+    DCHECK(furthestBlock->isAbove(formattingElementRecord));
     HTMLStackItem* commonAncestor =
         formattingElementRecord->next()->stackItem();
     // 8.
     HTMLFormattingElementList::Bookmark bookmark =
         m_tree.activeFormattingElements()->bookmarkFor(formattingElement);
     // 9.
     HTMLElementStack::ElementRecord* node = furthestBlock;
     HTMLElementStack::ElementRecord* nextNode = node->next();
     HTMLElementStack::ElementRecord* lastNode = furthestBlock;
     // 9.1, 9.2, 9.3 and 9.11 are covered by the for() loop.
     for (int i = 0; i < innerIterationLimit; ++i) {
       // 9.4
       node = nextNode;
-      ASSERT(node);
+      DCHECK(node);
       // Save node->next() for the next iteration in case node is deleted in
       // 9.5.
       nextNode = node->next();
       // 9.5
       if (!m_tree.activeFormattingElements()->contains(node->element())) {
         m_tree.openElements()->remove(node->element());
         node = 0;
         continue;
       }
       // 9.6
@@ skipping 82 matching lines @@
     }
     if (item->hasTagName(bodyTag))
       return setInsertionMode(InBodyMode);
     if (item->hasTagName(framesetTag)) {
       return setInsertionMode(InFramesetMode);
     }
     if (item->hasTagName(htmlTag)) {
       if (m_tree.headStackItem())
         return setInsertionMode(AfterHeadMode);
 
-      ASSERT(isParsingFragment());
+      DCHECK(isParsingFragment());
       return setInsertionMode(BeforeHeadMode);
     }
     if (last) {
-      ASSERT(isParsingFragment());
+      DCHECK(isParsingFragment());
       return setInsertionMode(InBodyMode);
     }
     nodeRecord = nodeRecord->next();
   }
 }
 
 void HTMLTreeBuilder::processEndTagForInTableBody(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::EndTag);
+  DCHECK_EQ(token->type(), HTMLToken::EndTag);
   if (isTableBodyContextTag(token->name())) {
     if (!m_tree.openElements()->inTableScope(token->name())) {
       parseError(token);
       return;
     }
     m_tree.openElements()->popUntilTableBodyScopeMarker();
     m_tree.openElements()->pop();
     setInsertionMode(InTableMode);
     return;
   }
   if (token->name() == tableTag) {
     // FIXME: This is slow.
     if (!m_tree.openElements()->inTableScope(tbodyTag) &&
         !m_tree.openElements()->inTableScope(theadTag) &&
         !m_tree.openElements()->inTableScope(tfootTag)) {
-      ASSERT(isParsingFragmentOrTemplateContents());
+      DCHECK(isParsingFragmentOrTemplateContents());
       parseError(token);
       return;
     }
     m_tree.openElements()->popUntilTableBodyScopeMarker();
-    ASSERT(isTableBodyContextTag(m_tree.currentStackItem()->localName()));
+    DCHECK(isTableBodyContextTag(m_tree.currentStackItem()->localName()));
     processFakeEndTag(m_tree.currentStackItem()->localName());
     processEndTag(token);
     return;
   }
   if (token->name() == bodyTag || isCaptionColOrColgroupTag(token->name()) ||
       token->name() == htmlTag || isTableCellContextTag(token->name()) ||
       token->name() == trTag) {
     parseError(token);
     return;
   }
   processEndTagForInTable(token);
 }
 
 void HTMLTreeBuilder::processEndTagForInRow(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::EndTag);
+  DCHECK_EQ(token->type(), HTMLToken::EndTag);
   if (token->name() == trTag) {
     processTrEndTagForInRow();
     return;
   }
   if (token->name() == tableTag) {
     if (!processTrEndTagForInRow()) {
-      ASSERT(isParsingFragmentOrTemplateContents());
+      DCHECK(isParsingFragmentOrTemplateContents());
       return;
     }
-    ASSERT(getInsertionMode() == InTableBodyMode);
+    DCHECK_EQ(getInsertionMode(), InTableBodyMode);
     processEndTag(token);
     return;
   }
   if (isTableBodyContextTag(token->name())) {
     if (!m_tree.openElements()->inTableScope(token->name())) {
       parseError(token);
       return;
     }
     processFakeEndTag(trTag);
-    ASSERT(getInsertionMode() == InTableBodyMode);
+    DCHECK_EQ(getInsertionMode(), InTableBodyMode);
     processEndTag(token);
     return;
   }
   if (token->name() == bodyTag || isCaptionColOrColgroupTag(token->name()) ||
       token->name() == htmlTag || isTableCellContextTag(token->name())) {
     parseError(token);
     return;
   }
   processEndTagForInTable(token);
 }
 
 void HTMLTreeBuilder::processEndTagForInCell(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::EndTag);
+  DCHECK_EQ(token->type(), HTMLToken::EndTag);
   if (isTableCellContextTag(token->name())) {
     if (!m_tree.openElements()->inTableScope(token->name())) {
       parseError(token);
       return;
     }
     m_tree.generateImpliedEndTags();
     if (!m_tree.currentStackItem()->matchesHTMLTag(token->name()))
       parseError(token);
     m_tree.openElements()->popUntilPopped(token->name());
     m_tree.activeFormattingElements()->clearToLastMarker();
     setInsertionMode(InRowMode);
     return;
   }
   if (token->name() == bodyTag || isCaptionColOrColgroupTag(token->name()) ||
       token->name() == htmlTag) {
     parseError(token);
     return;
   }
   if (token->name() == tableTag || token->name() == trTag ||
       isTableBodyContextTag(token->name())) {
     if (!m_tree.openElements()->inTableScope(token->name())) {
-      ASSERT(isTableBodyContextTag(token->name()) ||
+      DCHECK(isTableBodyContextTag(token->name()) ||
              m_tree.openElements()->inTableScope(templateTag) ||
              isParsingFragment());
       parseError(token);
       return;
     }
     closeTheCell();
     processEndTag(token);
     return;
   }
   processEndTagForInBody(token);
 }
 
 void HTMLTreeBuilder::processEndTagForInBody(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::EndTag);
+  DCHECK_EQ(token->type(), HTMLToken::EndTag);
   if (token->name() == bodyTag) {
     processBodyEndTagForInBody(token);
     return;
   }
   if (token->name() == htmlTag) {
     AtomicHTMLToken endBody(HTMLToken::EndTag, bodyTag.localName());
     if (processBodyEndTagForInBody(&endBody))
       processEndTag(token);
     return;
   }
@@ skipping 28 matching lines @@
     }
     m_tree.generateImpliedEndTags();
     if (m_tree.currentElement() != node)
       parseError(token);
     m_tree.openElements()->remove(node);
   }
   if (token->name() == pTag) {
     if (!m_tree.openElements()->inButtonScope(token->name())) {
       parseError(token);
       processFakeStartTag(pTag);
-      ASSERT(m_tree.openElements()->inScope(token->name()));
+      DCHECK(m_tree.openElements()->inScope(token->name()));
       processEndTag(token);
       return;
     }
     m_tree.generateImpliedEndTagsWithExclusion(token->name());
     if (!m_tree.currentStackItem()->matchesHTMLTag(token->name()))
       parseError(token);
     m_tree.openElements()->popUntilPopped(token->name());
     return;
   }
   if (token->name() == liTag) {
@@ skipping 53 matching lines @@
   }
   if (token->name() == templateTag) {
     processTemplateEndTag(token);
     return;
   }
   processAnyOtherEndTagForInBody(token);
 }
 
 bool HTMLTreeBuilder::processCaptionEndTagForInCaption() {
   if (!m_tree.openElements()->inTableScope(captionTag.localName())) {
-    ASSERT(isParsingFragment());
+    DCHECK(isParsingFragment());
     // FIXME: parse error
     return false;
   }
   m_tree.generateImpliedEndTags();
   // FIXME: parse error if (!m_tree.currentStackItem()->hasTagName(captionTag))
   m_tree.openElements()->popUntilPopped(captionTag.localName());
   m_tree.activeFormattingElements()->clearToLastMarker();
   setInsertionMode(InTableMode);
   return true;
 }
 
 bool HTMLTreeBuilder::processTrEndTagForInRow() {
   if (!m_tree.openElements()->inTableScope(trTag)) {
-    ASSERT(isParsingFragmentOrTemplateContents());
+    DCHECK(isParsingFragmentOrTemplateContents());
     // FIXME: parse error
     return false;
   }
   m_tree.openElements()->popUntilTableRowScopeMarker();
-  ASSERT(m_tree.currentStackItem()->hasTagName(trTag));
+  DCHECK(m_tree.currentStackItem()->hasTagName(trTag));
   m_tree.openElements()->pop();
   setInsertionMode(InTableBodyMode);
   return true;
 }
 
 bool HTMLTreeBuilder::processTableEndTagForInTable() {
   if (!m_tree.openElements()->inTableScope(tableTag)) {
-    ASSERT(isParsingFragmentOrTemplateContents());
+    DCHECK(isParsingFragmentOrTemplateContents());
     // FIXME: parse error.
     return false;
   }
   m_tree.openElements()->popUntilPopped(tableTag.localName());
   resetInsertionModeAppropriately();
   return true;
 }
 
 void HTMLTreeBuilder::processEndTagForInTable(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::EndTag);
+  DCHECK_EQ(token->type(), HTMLToken::EndTag);
   if (token->name() == tableTag) {
     processTableEndTagForInTable();
     return;
   }
   if (token->name() == bodyTag || isCaptionColOrColgroupTag(token->name()) ||
       token->name() == htmlTag || isTableBodyContextTag(token->name()) ||
       isTableCellContextTag(token->name()) || token->name() == trTag) {
     parseError(token);
     return;
   }
   parseError(token);
   // Is this redirection necessary here?
   HTMLConstructionSite::RedirectToFosterParentGuard redirecter(m_tree);
   processEndTagForInBody(token);
 }
 
 void HTMLTreeBuilder::processEndTag(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::EndTag);
+  DCHECK_EQ(token->type(), HTMLToken::EndTag);
   switch (getInsertionMode()) {
     case InitialMode:
-      ASSERT(getInsertionMode() == InitialMode);
+      DCHECK_EQ(getInsertionMode(), InitialMode);
       defaultForInitial();
     // Fall through.
     case BeforeHTMLMode:
-      ASSERT(getInsertionMode() == BeforeHTMLMode);
+      DCHECK_EQ(getInsertionMode(), BeforeHTMLMode);
       if (token->name() != headTag && token->name() != bodyTag &&
           token->name() != htmlTag && token->name() != brTag) {
         parseError(token);
         return;
       }
       defaultForBeforeHTML();
     // Fall through.
     case BeforeHeadMode:
-      ASSERT(getInsertionMode() == BeforeHeadMode);
+      DCHECK_EQ(getInsertionMode(), BeforeHeadMode);
       if (token->name() != headTag && token->name() != bodyTag &&
           token->name() != htmlTag && token->name() != brTag) {
         parseError(token);
         return;
       }
       defaultForBeforeHead();
     // Fall through.
     case InHeadMode:
-      ASSERT(getInsertionMode() == InHeadMode);
+      DCHECK_EQ(getInsertionMode(), InHeadMode);
       // FIXME: This case should be broken out into processEndTagForInHead,
       // because other end tag cases now refer to it ("process the token for
       // using the rules of the "in head" insertion mode"). but because the
       // logic falls through to AfterHeadMode, that gets a little messy.
       if (token->name() == templateTag) {
         processTemplateEndTag(token);
         return;
       }
       if (token->name() == headTag) {
         m_tree.openElements()->popHTMLHeadElement();
         setInsertionMode(AfterHeadMode);
         return;
       }
       if (token->name() != bodyTag && token->name() != htmlTag &&
           token->name() != brTag) {
         parseError(token);
         return;
       }
       defaultForInHead();
     // Fall through.
     case AfterHeadMode:
-      ASSERT(getInsertionMode() == AfterHeadMode);
+      DCHECK_EQ(getInsertionMode(), AfterHeadMode);
       if (token->name() != bodyTag && token->name() != htmlTag &&
           token->name() != brTag) {
         parseError(token);
         return;
       }
       defaultForAfterHead();
     // Fall through
     case InBodyMode:
-      ASSERT(getInsertionMode() == InBodyMode);
+      DCHECK_EQ(getInsertionMode(), InBodyMode);
       processEndTagForInBody(token);
       break;
     case InTableMode:
-      ASSERT(getInsertionMode() == InTableMode);
+      DCHECK_EQ(getInsertionMode(), InTableMode);
       processEndTagForInTable(token);
       break;
     case InCaptionMode:
-      ASSERT(getInsertionMode() == InCaptionMode);
+      DCHECK_EQ(getInsertionMode(), InCaptionMode);
       if (token->name() == captionTag) {
         processCaptionEndTagForInCaption();
         return;
       }
       if (token->name() == tableTag) {
         parseError(token);
         if (!processCaptionEndTagForInCaption()) {
-          ASSERT(isParsingFragment());
+          DCHECK(isParsingFragment());
           return;
         }
         processEndTag(token);
         return;
       }
       if (token->name() == bodyTag || token->name() == colTag ||
           token->name() == colgroupTag || token->name() == htmlTag ||
           isTableBodyContextTag(token->name()) ||
           isTableCellContextTag(token->name()) || token->name() == trTag) {
         parseError(token);
         return;
       }
       processEndTagForInBody(token);
       break;
     case InColumnGroupMode:
-      ASSERT(getInsertionMode() == InColumnGroupMode);
+      DCHECK_EQ(getInsertionMode(), InColumnGroupMode);
       if (token->name() == colgroupTag) {
         processColgroupEndTagForInColumnGroup();
         return;
       }
       if (token->name() == colTag) {
         parseError(token);
         return;
       }
       if (token->name() == templateTag) {
         processTemplateEndTag(token);
         return;
       }
       if (!processColgroupEndTagForInColumnGroup()) {
-        ASSERT(isParsingFragmentOrTemplateContents());
+        DCHECK(isParsingFragmentOrTemplateContents());
         return;
       }
       processEndTag(token);
       break;
     case InRowMode:
-      ASSERT(getInsertionMode() == InRowMode);
+      DCHECK_EQ(getInsertionMode(), InRowMode);
       processEndTagForInRow(token);
       break;
     case InCellMode:
-      ASSERT(getInsertionMode() == InCellMode);
+      DCHECK_EQ(getInsertionMode(), InCellMode);
       processEndTagForInCell(token);
       break;
     case InTableBodyMode:
-      ASSERT(getInsertionMode() == InTableBodyMode);
+      DCHECK_EQ(getInsertionMode(), InTableBodyMode);
       processEndTagForInTableBody(token);
       break;
     case AfterBodyMode:
-      ASSERT(getInsertionMode() == AfterBodyMode);
+      DCHECK_EQ(getInsertionMode(), AfterBodyMode);
       if (token->name() == htmlTag) {
         if (isParsingFragment()) {
           parseError(token);
           return;
         }
         setInsertionMode(AfterAfterBodyMode);
         return;
       }
     // Fall through.
     case AfterAfterBodyMode:
-      ASSERT(getInsertionMode() == AfterBodyMode ||
+      DCHECK(getInsertionMode() == AfterBodyMode ||
              getInsertionMode() == AfterAfterBodyMode);
       parseError(token);
       setInsertionMode(InBodyMode);
       processEndTag(token);
       break;
     case InHeadNoscriptMode:
-      ASSERT(getInsertionMode() == InHeadNoscriptMode);
+      DCHECK_EQ(getInsertionMode(), InHeadNoscriptMode);
       if (token->name() == noscriptTag) {
-        ASSERT(m_tree.currentStackItem()->hasTagName(noscriptTag));
+        DCHECK(m_tree.currentStackItem()->hasTagName(noscriptTag));
         m_tree.openElements()->pop();
-        ASSERT(m_tree.currentStackItem()->hasTagName(headTag));
+        DCHECK(m_tree.currentStackItem()->hasTagName(headTag));
         setInsertionMode(InHeadMode);
         return;
       }
       if (token->name() != brTag) {
         parseError(token);
         return;
       }
       defaultForInHeadNoscript();
       processToken(token);
       break;
@@ skipping 11 matching lines @@
           // We must set the tokenizer's state to DataState explicitly if the
           // tokenizer didn't have a chance to.
           m_parser->tokenizer()->setState(HTMLTokenizer::DataState);
         }
         return;
       }
       m_tree.openElements()->pop();
       setInsertionMode(m_originalInsertionMode);
       break;
     case InFramesetMode:
-      ASSERT(getInsertionMode() == InFramesetMode);
+      DCHECK_EQ(getInsertionMode(), InFramesetMode);
       if (token->name() == framesetTag) {
         bool ignoreFramesetForFragmentParsing = m_tree.currentIsRootNode();
         ignoreFramesetForFragmentParsing =
             ignoreFramesetForFragmentParsing ||
             m_tree.openElements()->hasTemplateInHTMLScope();
         if (ignoreFramesetForFragmentParsing) {
-          ASSERT(isParsingFragmentOrTemplateContents());
+          DCHECK(isParsingFragmentOrTemplateContents());
           parseError(token);
           return;
         }
         m_tree.openElements()->pop();
         if (!isParsingFragment() &&
             !m_tree.currentStackItem()->hasTagName(framesetTag))
           setInsertionMode(AfterFramesetMode);
         return;
       }
       if (token->name() == templateTag) {
         processTemplateEndTag(token);
         return;
       }
       break;
     case AfterFramesetMode:
-      ASSERT(getInsertionMode() == AfterFramesetMode);
+      DCHECK_EQ(getInsertionMode(), AfterFramesetMode);
       if (token->name() == htmlTag) {
         setInsertionMode(AfterAfterFramesetMode);
         return;
       }
     // Fall through.
     case AfterAfterFramesetMode:
-      ASSERT(getInsertionMode() == AfterFramesetMode ||
+      DCHECK(getInsertionMode() == AfterFramesetMode ||
              getInsertionMode() == AfterAfterFramesetMode);
       parseError(token);
       break;
     case InSelectInTableMode:
-      ASSERT(getInsertionMode() == InSelectInTableMode);
+      DCHECK(getInsertionMode() == InSelectInTableMode);
       if (token->name() == captionTag || token->name() == tableTag ||
           isTableBodyContextTag(token->name()) || token->name() == trTag ||
           isTableCellContextTag(token->name())) {
         parseError(token);
         if (m_tree.openElements()->inTableScope(token->name())) {
           AtomicHTMLToken endSelect(HTMLToken::EndTag, selectTag.localName());
           processEndTag(&endSelect);
           processEndTag(token);
         }
         return;
       }
     // Fall through.
     case InSelectMode:
-      ASSERT(getInsertionMode() == InSelectMode ||
+      DCHECK(getInsertionMode() == InSelectMode ||
              getInsertionMode() == InSelectInTableMode);
       if (token->name() == optgroupTag) {
         if (m_tree.currentStackItem()->hasTagName(optionTag) &&
             m_tree.oneBelowTop() &&
             m_tree.oneBelowTop()->hasTagName(optgroupTag))
           processFakeEndTag(optionTag);
         if (m_tree.currentStackItem()->hasTagName(optgroupTag)) {
           m_tree.openElements()->pop();
           return;
         }
         parseError(token);
         return;
       }
       if (token->name() == optionTag) {
         if (m_tree.currentStackItem()->hasTagName(optionTag)) {
           m_tree.openElements()->pop();
           return;
         }
         parseError(token);
         return;
       }
       if (token->name() == selectTag) {
         if (!m_tree.openElements()->inSelectScope(token->name())) {
-          ASSERT(isParsingFragment());
+          DCHECK(isParsingFragment());
           parseError(token);
           return;
         }
         m_tree.openElements()->popUntilPopped(selectTag.localName());
         resetInsertionModeAppropriately();
         return;
       }
       if (token->name() == templateTag) {
         processTemplateEndTag(token);
         return;
       }
       break;
     case InTableTextMode:
       defaultForInTableText();
       processEndTag(token);
       break;
     case TemplateContentsMode:
       if (token->name() == templateTag) {
         processTemplateEndTag(token);
         return;
       }
       break;
   }
 }
 
 void HTMLTreeBuilder::processComment(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::Comment);
+  DCHECK_EQ(token->type(), HTMLToken::Comment);
   if (m_insertionMode == InitialMode || m_insertionMode == BeforeHTMLMode ||
       m_insertionMode == AfterAfterBodyMode ||
       m_insertionMode == AfterAfterFramesetMode) {
     m_tree.insertCommentOnDocument(token);
     return;
   }
   if (m_insertionMode == AfterBodyMode) {
     m_tree.insertCommentOnHTMLHtmlElement(token);
     return;
   }
   if (m_insertionMode == InTableTextMode) {
     defaultForInTableText();
     processComment(token);
     return;
   }
   m_tree.insertComment(token);
 }
 
 void HTMLTreeBuilder::processCharacter(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::Character);
+  DCHECK_EQ(token->type(), HTMLToken::Character);
   CharacterTokenBuffer buffer(token);
   processCharacterBuffer(buffer);
 }
 
 void HTMLTreeBuilder::processCharacterBuffer(CharacterTokenBuffer& buffer) {
 ReprocessBuffer:
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#parsing-main-inbody
   // Note that this logic is different than the generic \r\n collapsing
   // handled in the input stream preprocessor. This logic is here as an
   // "authoring convenience" so folks can write:
   //
   // <pre>
   // lorem ipsum
   // lorem ipsum
   // </pre>
   //
   // without getting an extra newline at the start of their <pre> element.
   if (m_shouldSkipLeadingNewline) {
     m_shouldSkipLeadingNewline = false;
     buffer.skipAtMostOneLeadingNewline();
     if (buffer.isEmpty())
       return;
   }
 
   switch (getInsertionMode()) {
     case InitialMode: {
-      ASSERT(getInsertionMode() == InitialMode);
+      DCHECK_EQ(getInsertionMode(), InitialMode);
       buffer.skipLeadingWhitespace();
       if (buffer.isEmpty())
         return;
       defaultForInitial();
       // Fall through.
     }
     case BeforeHTMLMode: {
-      ASSERT(getInsertionMode() == BeforeHTMLMode);
+      DCHECK_EQ(getInsertionMode(), BeforeHTMLMode);
       buffer.skipLeadingWhitespace();
       if (buffer.isEmpty())
         return;
       defaultForBeforeHTML();
       if (m_parser->isStopped()) {
         buffer.skipRemaining();
         return;
       }
       // Fall through.
     }
     case BeforeHeadMode: {
-      ASSERT(getInsertionMode() == BeforeHeadMode);
+      DCHECK_EQ(getInsertionMode(), BeforeHeadMode);
       buffer.skipLeadingWhitespace();
       if (buffer.isEmpty())
         return;
       defaultForBeforeHead();
       // Fall through.
     }
     case InHeadMode: {
-      ASSERT(getInsertionMode() == InHeadMode);
+      DCHECK_EQ(getInsertionMode(), InHeadMode);
       StringView leadingWhitespace = buffer.takeLeadingWhitespace();
       if (!leadingWhitespace.isEmpty())
         m_tree.insertTextNode(leadingWhitespace, AllWhitespace);
       if (buffer.isEmpty())
         return;
       defaultForInHead();
       // Fall through.
     }
     case AfterHeadMode: {
-      ASSERT(getInsertionMode() == AfterHeadMode);
+      DCHECK_EQ(getInsertionMode(), AfterHeadMode);
       StringView leadingWhitespace = buffer.takeLeadingWhitespace();
       if (!leadingWhitespace.isEmpty())
         m_tree.insertTextNode(leadingWhitespace, AllWhitespace);
       if (buffer.isEmpty())
         return;
       defaultForAfterHead();
       // Fall through.
     }
     case InBodyMode:
     case InCaptionMode:
     case TemplateContentsMode:
     case InCellMode: {
-      ASSERT(getInsertionMode() == InBodyMode ||
+      DCHECK(getInsertionMode() == InBodyMode ||
              getInsertionMode() == InCaptionMode ||
              getInsertionMode() == InCellMode ||
              getInsertionMode() == TemplateContentsMode);
       processCharacterBufferForInBody(buffer);
       break;
     }
     case InTableMode:
     case InTableBodyMode:
     case InRowMode: {
-      ASSERT(getInsertionMode() == InTableMode ||
+      DCHECK(getInsertionMode() == InTableMode ||
              getInsertionMode() == InTableBodyMode ||
              getInsertionMode() == InRowMode);
-      ASSERT(m_pendingTableCharacters.isEmpty());
+      DCHECK(m_pendingTableCharacters.isEmpty());
       if (m_tree.currentStackItem()->isElementNode() &&
           (m_tree.currentStackItem()->hasTagName(tableTag) ||
            m_tree.currentStackItem()->hasTagName(tbodyTag) ||
            m_tree.currentStackItem()->hasTagName(tfootTag) ||
            m_tree.currentStackItem()->hasTagName(theadTag) ||
            m_tree.currentStackItem()->hasTagName(trTag))) {
         m_originalInsertionMode = m_insertionMode;
         setInsertionMode(InTableTextMode);
         // Note that we fall through to the InTableTextMode case below.
       } else {
         HTMLConstructionSite::RedirectToFosterParentGuard redirecter(m_tree);
         processCharacterBufferForInBody(buffer);
         break;
       }
       // Fall through.
     }
     case InTableTextMode: {
       buffer.giveRemainingTo(m_pendingTableCharacters);
       break;
     }
     case InColumnGroupMode: {
-      ASSERT(getInsertionMode() == InColumnGroupMode);
+      DCHECK_EQ(getInsertionMode(), InColumnGroupMode);
       StringView leadingWhitespace = buffer.takeLeadingWhitespace();
       if (!leadingWhitespace.isEmpty())
         m_tree.insertTextNode(leadingWhitespace, AllWhitespace);
       if (buffer.isEmpty())
         return;
       if (!processColgroupEndTagForInColumnGroup()) {
-        ASSERT(isParsingFragmentOrTemplateContents());
+        DCHECK(isParsingFragmentOrTemplateContents());
         // The spec tells us to drop these characters on the floor.
         buffer.skipLeadingNonWhitespace();
         if (buffer.isEmpty())
           return;
       }
       goto ReprocessBuffer;
     }
     case AfterBodyMode:
     case AfterAfterBodyMode: {
-      ASSERT(getInsertionMode() == AfterBodyMode ||
+      DCHECK(getInsertionMode() == AfterBodyMode ||
              getInsertionMode() == AfterAfterBodyMode);
       // FIXME: parse error
       setInsertionMode(InBodyMode);
       goto ReprocessBuffer;
     }
     case TextMode: {
-      ASSERT(getInsertionMode() == TextMode);
+      DCHECK_EQ(getInsertionMode(), TextMode);
       m_tree.insertTextNode(buffer.takeRemaining());
       break;
     }
     case InHeadNoscriptMode: {
-      ASSERT(getInsertionMode() == InHeadNoscriptMode);
+      DCHECK_EQ(getInsertionMode(), InHeadNoscriptMode);
       StringView leadingWhitespace = buffer.takeLeadingWhitespace();
       if (!leadingWhitespace.isEmpty())
         m_tree.insertTextNode(leadingWhitespace, AllWhitespace);
       if (buffer.isEmpty())
         return;
       defaultForInHeadNoscript();
       goto ReprocessBuffer;
     }
     case InFramesetMode:
     case AfterFramesetMode: {
-      ASSERT(getInsertionMode() == InFramesetMode ||
+      DCHECK(getInsertionMode() == InFramesetMode ||
              getInsertionMode() == AfterFramesetMode ||
              getInsertionMode() == AfterAfterFramesetMode);
       String leadingWhitespace = buffer.takeRemainingWhitespace();
       if (!leadingWhitespace.isEmpty())
         m_tree.insertTextNode(leadingWhitespace, AllWhitespace);
       // FIXME: We should generate a parse error if we skipped over any
       // non-whitespace characters.
       break;
     }
     case InSelectInTableMode:
     case InSelectMode: {
-      ASSERT(getInsertionMode() == InSelectMode ||
+      DCHECK(getInsertionMode() == InSelectMode ||
              getInsertionMode() == InSelectInTableMode);
       m_tree.insertTextNode(buffer.takeRemaining());
       break;
     }
     case AfterAfterFramesetMode: {
       String leadingWhitespace = buffer.takeRemainingWhitespace();
       if (!leadingWhitespace.isEmpty()) {
         m_tree.reconstructTheActiveFormattingElements();
         m_tree.insertTextNode(leadingWhitespace, AllWhitespace);
       }
       // FIXME: We should generate a parse error if we skipped over any
       // non-whitespace characters.
       break;
     }
   }
 }
 
 void HTMLTreeBuilder::processCharacterBufferForInBody(
     CharacterTokenBuffer& buffer) {
   m_tree.reconstructTheActiveFormattingElements();
   StringView characters = buffer.takeRemaining();
   m_tree.insertTextNode(characters);
   if (m_framesetOk && !isAllWhitespaceOrReplacementCharacters(characters))
     m_framesetOk = false;
 }
 
 void HTMLTreeBuilder::processEndOfFile(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::EndOfFile);
+  DCHECK_EQ(token->type(), HTMLToken::EndOfFile);
   switch (getInsertionMode()) {
     case InitialMode:
-      ASSERT(getInsertionMode() == InitialMode);
+      DCHECK_EQ(getInsertionMode(), InitialMode);
       defaultForInitial();
     // Fall through.
     case BeforeHTMLMode:
-      ASSERT(getInsertionMode() == BeforeHTMLMode);
+      DCHECK_EQ(getInsertionMode(), BeforeHTMLMode);
       defaultForBeforeHTML();
     // Fall through.
     case BeforeHeadMode:
-      ASSERT(getInsertionMode() == BeforeHeadMode);
+      DCHECK_EQ(getInsertionMode(), BeforeHeadMode);
       defaultForBeforeHead();
     // Fall through.
     case InHeadMode:
-      ASSERT(getInsertionMode() == InHeadMode);
+      DCHECK_EQ(getInsertionMode(), InHeadMode);
       defaultForInHead();
     // Fall through.
     case AfterHeadMode:
-      ASSERT(getInsertionMode() == AfterHeadMode);
+      DCHECK_EQ(getInsertionMode(), AfterHeadMode);
       defaultForAfterHead();
     // Fall through
     case InBodyMode:
     case InCellMode:
     case InCaptionMode:
     case InRowMode:
-      ASSERT(getInsertionMode() == InBodyMode ||
+      DCHECK(getInsertionMode() == InBodyMode ||
              getInsertionMode() == InCellMode ||
              getInsertionMode() == InCaptionMode ||
              getInsertionMode() == InRowMode ||
              getInsertionMode() == TemplateContentsMode);
       // Emit parse error based on what elements are still open.
       DVLOG(1) << "Not implemented.";
       if (!m_templateInsertionModes.isEmpty() &&
           processEndOfFileForInTemplateContents(token))
         return;
       break;
     case AfterBodyMode:
     case AfterAfterBodyMode:
-      ASSERT(getInsertionMode() == AfterBodyMode ||
+      DCHECK(getInsertionMode() == AfterBodyMode ||
              getInsertionMode() == AfterAfterBodyMode);
       break;
     case InHeadNoscriptMode:
-      ASSERT(getInsertionMode() == InHeadNoscriptMode);
+      DCHECK_EQ(getInsertionMode(), InHeadNoscriptMode);
       defaultForInHeadNoscript();
       processEndOfFile(token);
       return;
     case AfterFramesetMode:
     case AfterAfterFramesetMode:
-      ASSERT(getInsertionMode() == AfterFramesetMode ||
+      DCHECK(getInsertionMode() == AfterFramesetMode ||
              getInsertionMode() == AfterAfterFramesetMode);
       break;
     case InColumnGroupMode:
       if (m_tree.currentIsRootNode()) {
-        ASSERT(isParsingFragment());
+        DCHECK(isParsingFragment());
         return;  // FIXME: Should we break here instead of returning?
       }
-      ASSERT(m_tree.currentNode()->hasTagName(colgroupTag) ||
+      DCHECK(m_tree.currentNode()->hasTagName(colgroupTag) ||
              isHTMLTemplateElement(m_tree.currentNode()));
       processColgroupEndTagForInColumnGroup();
     // Fall through
     case InFramesetMode:
     case InTableMode:
     case InTableBodyMode:
     case InSelectInTableMode:
     case InSelectMode:
-      ASSERT(getInsertionMode() == InSelectMode ||
+      DCHECK(getInsertionMode() == InSelectMode ||
              getInsertionMode() == InSelectInTableMode ||
              getInsertionMode() == InTableMode ||
              getInsertionMode() == InFramesetMode ||
              getInsertionMode() == InTableBodyMode ||
              getInsertionMode() == InColumnGroupMode);
       if (m_tree.currentNode() != m_tree.openElements()->rootNode())
         parseError(token);
       if (!m_templateInsertionModes.isEmpty() &&
           processEndOfFileForInTemplateContents(token))
         return;
       break;
     case InTableTextMode:
       defaultForInTableText();
       processEndOfFile(token);
       return;
     case TextMode: {
       parseError(token);
       if (m_tree.currentStackItem()->hasTagName(scriptTag)) {
         // Mark the script element as "already started".
         DVLOG(1) << "Not implemented.";
       }
       Element* el = m_tree.openElements()->top();
       if (isHTMLTextAreaElement(el))
         toHTMLFormControlElement(el)->setBlocksFormSubmission(true);
       m_tree.openElements()->pop();
-      ASSERT(m_originalInsertionMode != TextMode);
+      DCHECK_NE(m_originalInsertionMode, TextMode);
       setInsertionMode(m_originalInsertionMode);
       processEndOfFile(token);
       return;
     }
     case TemplateContentsMode:
       if (processEndOfFileForInTemplateContents(token))
         return;
       break;
   }
   m_tree.processEndOfFile();
@@ skipping 43 matching lines @@
     m_tree.insertTextNode(characters, NotAllWhitespace);
     m_framesetOk = false;
     setInsertionMode(m_originalInsertionMode);
     return;
   }
   m_tree.insertTextNode(characters);
   setInsertionMode(m_originalInsertionMode);
 }
 
 bool HTMLTreeBuilder::processStartTagForInHead(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::StartTag);
+  DCHECK_EQ(token->type(), HTMLToken::StartTag);
   if (token->name() == htmlTag) {
     processHtmlStartTagForInBody(token);
     return true;
   }
   if (token->name() == baseTag || token->name() == basefontTag ||
       token->name() == bgsoundTag || token->name() == commandTag ||
       token->name() == linkTag || token->name() == metaTag) {
     m_tree.insertSelfClosingHTMLElementDestroyingToken(token);
     // Note: The custom processing for the <meta> tag is done in
     // HTMLMetaElement::process().
@@ skipping 25 matching lines @@
     return true;
   }
   if (token->name() == headTag) {
     parseError(token);
     return true;
   }
   return false;
 }
 
 void HTMLTreeBuilder::processGenericRCDATAStartTag(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::StartTag);
+  DCHECK_EQ(token->type(), HTMLToken::StartTag);
   m_tree.insertHTMLElement(token);
   if (m_parser->tokenizer())
     m_parser->tokenizer()->setState(HTMLTokenizer::RCDATAState);
   m_originalInsertionMode = m_insertionMode;
   setInsertionMode(TextMode);
 }
 
 void HTMLTreeBuilder::processGenericRawTextStartTag(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::StartTag);
+  DCHECK_EQ(token->type(), HTMLToken::StartTag);
   m_tree.insertHTMLElement(token);
   if (m_parser->tokenizer())
     m_parser->tokenizer()->setState(HTMLTokenizer::RAWTEXTState);
   m_originalInsertionMode = m_insertionMode;
   setInsertionMode(TextMode);
 }
 
 void HTMLTreeBuilder::processScriptStartTag(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::StartTag);
+  DCHECK_EQ(token->type(), HTMLToken::StartTag);
   m_tree.insertScriptElement(token);
   if (m_parser->tokenizer())
     m_parser->tokenizer()->setState(HTMLTokenizer::ScriptDataState);
   m_originalInsertionMode = m_insertionMode;
 
   TextPosition position = m_parser->textPosition();
 
   m_scriptToProcessStartPosition = position;
 
   setInsertionMode(TextMode);
@@ skipping 37 matching lines @@
     if (m_framesetOk && !isAllWhitespaceOrReplacementCharacters(characters))
       m_framesetOk = false;
     return;
   }
 
   m_tree.flush(FlushAlways);
   HTMLStackItem* adjustedCurrentNode = adjustedCurrentStackItem();
 
   switch (token->type()) {
     case HTMLToken::Uninitialized:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       break;
     case HTMLToken::DOCTYPE:
       parseError(token);
       break;
     case HTMLToken::StartTag: {
       if (token->name() == bTag || token->name() == bigTag ||
           token->name() == blockquoteTag || token->name() == bodyTag ||
           token->name() == brTag || token->name() == centerTag ||
           token->name() == codeTag || token->name() == ddTag ||
           token->name() == divTag || token->name() == dlTag ||
@@ skipping 64 matching lines @@
       // Otherwise, process the token according to the rules given in the
       // section corresponding to the current insertion mode in HTML content.
       processEndTag(token);
       break;
     }
     case HTMLToken::Comment:
       m_tree.insertComment(token);
       break;
     case HTMLToken::Character:
     case HTMLToken::EndOfFile:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       break;
   }
 }
 
 void HTMLTreeBuilder::finished() {
   if (isParsingFragment())
     return;
 
-  ASSERT(m_templateInsertionModes.isEmpty());
-  ASSERT(m_isAttached);
+  DCHECK(m_templateInsertionModes.isEmpty());
+#if DCHECK_IS_ON()
+  DCHECK(m_isAttached);
+#endif
   // Warning, this may detach the parser. Do not do anything else after this.
   m_tree.finishedParsing();
 }
 
 void HTMLTreeBuilder::parseError(AtomicHTMLToken*) {}
 
 #ifndef NDEBUG
 const char* HTMLTreeBuilder::toString(HTMLTreeBuilder::InsertionMode mode) {
   switch (mode) {
 #define DEFINE_STRINGIFY(mode) \
@@ skipping 22 matching lines @@
     DEFINE_STRINGIFY(AfterFramesetMode)
     DEFINE_STRINGIFY(AfterAfterBodyMode)
     DEFINE_STRINGIFY(AfterAfterFramesetMode)
 #undef DEFINE_STRINGIFY
   }
   return "<unknown>";
 }
 #endif
 
 }  // namespace blink