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

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

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  * Copyright (C) 2011 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 94 matching lines @@
   // https://html.spec.whatwg.org/#insert-a-foreign-element
   // 3.1, (3) Push (pop) an element queue
   CEReactionsScope reactions;
   if (task.nextChild)
     task.parent->parserInsertBefore(task.child.get(), *task.nextChild);
   else
     task.parent->parserAppendChild(task.child.get());
 }
 
 static inline void executeInsertTask(HTMLConstructionSiteTask& task) {
-  ASSERT(task.operation == HTMLConstructionSiteTask::Insert);
+  DCHECK_EQ(task.operation, HTMLConstructionSiteTask::Insert);
 
   insert(task);
 
   if (task.child->isElementNode()) {
     Element& child = toElement(*task.child);
     child.beginParsingChildren();
     if (task.selfClosing)
       child.finishParsingChildren();
   }
 }
 
 static inline void executeInsertTextTask(HTMLConstructionSiteTask& task) {
-  ASSERT(task.operation == HTMLConstructionSiteTask::InsertText);
-  ASSERT(task.child->isTextNode());
+  DCHECK_EQ(task.operation, HTMLConstructionSiteTask::InsertText);
+  DCHECK(task.child->isTextNode());
 
   // Merge text nodes into previous ones if possible:
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#insert-a-character
   Text* newText = toText(task.child.get());
   Node* previousChild = task.nextChild ? task.nextChild->previousSibling()
                                        : task.parent->lastChild();
   if (previousChild && previousChild->isTextNode()) {
     Text* previousText = toText(previousChild);
     unsigned lengthLimit = textLengthLimitForContainer(*task.parent);
     if (previousText->length() + newText->length() < lengthLimit) {
       previousText->parserAppendData(newText->data());
       return;
     }
   }
 
   insert(task);
 }
 
 static inline void executeReparentTask(HTMLConstructionSiteTask& task) {
-  ASSERT(task.operation == HTMLConstructionSiteTask::Reparent);
+  DCHECK_EQ(task.operation, HTMLConstructionSiteTask::Reparent);
 
   task.parent->parserAppendChild(task.child);
 }
 
 static inline void executeInsertAlreadyParsedChildTask(
     HTMLConstructionSiteTask& task) {
-  ASSERT(task.operation == HTMLConstructionSiteTask::InsertAlreadyParsedChild);
+  DCHECK_EQ(task.operation, HTMLConstructionSiteTask::InsertAlreadyParsedChild);
 
   insert(task);
 }
 
 static inline void executeTakeAllChildrenTask(HTMLConstructionSiteTask& task) {
-  ASSERT(task.operation == HTMLConstructionSiteTask::TakeAllChildren);
+  DCHECK_EQ(task.operation, HTMLConstructionSiteTask::TakeAllChildren);
 
   task.parent->parserTakeAllChildrenFrom(*task.oldParent());
 }
 
 void HTMLConstructionSite::executeTask(HTMLConstructionSiteTask& task) {
-  ASSERT(m_taskQueue.isEmpty());
+  DCHECK(m_taskQueue.isEmpty());
   if (task.operation == HTMLConstructionSiteTask::Insert)
     return executeInsertTask(task);
 
   if (task.operation == HTMLConstructionSiteTask::InsertText)
     return executeInsertTextTask(task);
 
   // All the cases below this point are only used by the adoption agency.
 
   if (task.operation == HTMLConstructionSiteTask::InsertAlreadyParsedChild)
     return executeInsertAlreadyParsedChildTask(task);
 
   if (task.operation == HTMLConstructionSiteTask::Reparent)
     return executeReparentTask(task);
 
   if (task.operation == HTMLConstructionSiteTask::TakeAllChildren)
     return executeTakeAllChildrenTask(task);
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
 }
 
 // This is only needed for TextDocuments where we might have text nodes
 // approaching the default length limit (~64k) and we don't want to break a text
 // node in the middle of a combining character.
 static unsigned findBreakIndexBetween(const StringBuilder& string,
                                       unsigned currentPosition,
                                       unsigned proposedBreakIndex) {
-  ASSERT(currentPosition < proposedBreakIndex);
-  ASSERT(proposedBreakIndex <= string.length());
+  DCHECK_LT(currentPosition, proposedBreakIndex);
+  DCHECK_LE(proposedBreakIndex, string.length());
   // The end of the string is always a valid break.
   if (proposedBreakIndex == string.length())
     return proposedBreakIndex;
 
   // Latin-1 does not have breakable boundaries. If we ever moved to a different
   // 8-bit encoding this could be wrong.
   if (string.is8Bit())
     return proposedBreakIndex;
 
   const UChar* breakSearchCharacters = string.characters16() + currentPosition;
@@ skipping 30 matching lines @@
     return;
 
   if (mode == FlushIfAtTextLimit &&
       !shouldUseLengthLimit(*m_pendingText.parent))
     return;
 
   PendingText pendingText;
   // Hold onto the current pending text on the stack so that queueTask doesn't
   // recurse infinitely.
   m_pendingText.swap(pendingText);
-  ASSERT(m_pendingText.isEmpty());
+  DCHECK(m_pendingText.isEmpty());
 
   // Splitting text nodes into smaller chunks contradicts HTML5 spec, but is
   // necessary for performance, see:
   // https://bugs.webkit.org/show_bug.cgi?id=55898
   unsigned lengthLimit = textLengthLimitForContainer(*pendingText.parent);
 
   unsigned currentPosition = 0;
   const StringBuilder& string = pendingText.stringBuilder;
   while (currentPosition < string.length()) {
     unsigned proposedBreakIndex =
         std::min(currentPosition + lengthLimit, string.length());
     unsigned breakIndex =
         findBreakIndexBetween(string, currentPosition, proposedBreakIndex);
-    ASSERT(breakIndex <= string.length());
+    DCHECK_LE(breakIndex, string.length());
     String substring =
         string.substring(currentPosition, breakIndex - currentPosition);
     substring = atomizeIfAllWhitespace(substring, pendingText.whitespaceMode);
 
     HTMLConstructionSiteTask task(HTMLConstructionSiteTask::InsertText);
     task.parent = pendingText.parent;
     task.nextChild = pendingText.nextChild;
     task.child = Text::create(task.parent->document(), substring);
     queueTask(task);
 
-    ASSERT(breakIndex > currentPosition);
-    ASSERT(breakIndex - currentPosition == substring.length());
-    ASSERT(toText(task.child.get())->length() == substring.length());
+    DCHECK_GT(breakIndex, currentPosition);
+    DCHECK_EQ(breakIndex - currentPosition, substring.length());
+    DCHECK_EQ(toText(task.child.get())->length(), substring.length());
     currentPosition = breakIndex;
   }
 }
 
 void HTMLConstructionSite::queueTask(const HTMLConstructionSiteTask& task) {
   flushPendingText(FlushAlways);
-  ASSERT(m_pendingText.isEmpty());
+  DCHECK(m_pendingText.isEmpty());
   m_taskQueue.push_back(task);
 }
 
 void HTMLConstructionSite::attachLater(ContainerNode* parent,
                                        Node* child,
                                        bool selfClosing) {
-  ASSERT(scriptingContentIsAllowed(m_parserContentPolicy) ||
+  DCHECK(scriptingContentIsAllowed(m_parserContentPolicy) ||
          !child->isElementNode() || !toElement(child)->isScriptElement());
-  ASSERT(pluginContentIsAllowed(m_parserContentPolicy) ||
+  DCHECK(pluginContentIsAllowed(m_parserContentPolicy) ||
          !isHTMLPlugInElement(child));
 
   HTMLConstructionSiteTask task(HTMLConstructionSiteTask::Insert);
   task.parent = parent;
   task.child = child;
   task.selfClosing = selfClosing;
 
   if (shouldFosterParent()) {
     fosterParent(task.child);
     return;
   }
 
   // Add as a sibling of the parent if we have reached the maximum depth
   // allowed.
   if (m_openElements.stackDepth() > maximumHTMLParserDOMTreeDepth &&
       task.parent->parentNode())
     task.parent = task.parent->parentNode();
 
-  ASSERT(task.parent);
+  DCHECK(task.parent);
   queueTask(task);
 }
 
 void HTMLConstructionSite::executeQueuedTasks() {
   // This has no affect on pendingText, and we may have pendingText remaining
   // after executing all other queued tasks.
   const size_t size = m_taskQueue.size();
   if (!size)
     return;
 
@@ skipping 12 matching lines @@
     HTMLParserReentryPermit* reentryPermit,
     Document& document,
     ParserContentPolicy parserContentPolicy)
     : m_reentryPermit(reentryPermit),
       m_document(&document),
       m_attachmentRoot(document),
       m_parserContentPolicy(parserContentPolicy),
       m_isParsingFragment(false),
       m_redirectAttachToFosterParent(false),
       m_inQuirksMode(document.inQuirksMode()) {
-  ASSERT(m_document->isHTMLDocument() || m_document->isXHTMLDocument());
+  DCHECK(m_document->isHTMLDocument() || m_document->isXHTMLDocument());
 }
 
 void HTMLConstructionSite::initFragmentParsing(DocumentFragment* fragment,
                                                Element* contextElement) {
   DCHECK(contextElement);
   DCHECK_EQ(m_document, &fragment->document());
   DCHECK_EQ(m_inQuirksMode, fragment->document().inQuirksMode());
   DCHECK(!m_isParsingFragment);
   DCHECK(!m_form);
 
   m_attachmentRoot = fragment;
   m_isParsingFragment = true;
 
   if (!contextElement->document().isTemplateDocument())
     m_form = Traversal<HTMLFormElement>::firstAncestorOrSelf(*contextElement);
 }
 
 HTMLConstructionSite::~HTMLConstructionSite() {
   // Depending on why we're being destroyed it might be OK to forget queued
   // tasks, but currently we don't expect to.
-  ASSERT(m_taskQueue.isEmpty());
+  DCHECK(m_taskQueue.isEmpty());
   // Currently we assume that text will never be the last token in the document
   // and that we'll always queue some additional task to cause it to flush.
-  ASSERT(m_pendingText.isEmpty());
+  DCHECK(m_pendingText.isEmpty());
 }
 
 DEFINE_TRACE(HTMLConstructionSite) {
   visitor->trace(m_document);
   visitor->trace(m_attachmentRoot);
   visitor->trace(m_head);
   visitor->trace(m_form);
   visitor->trace(m_openElements);
   visitor->trace(m_activeFormattingElements);
   visitor->trace(m_taskQueue);
   visitor->trace(m_pendingText);
 }
 
 void HTMLConstructionSite::detach() {
   // FIXME: We'd like to ASSERT here that we're canceling and not just
   // discarding text that really should have made it into the DOM earlier, but
   // there doesn't seem to be a nice way to do that.
   m_pendingText.discard();
   m_document = nullptr;
   m_attachmentRoot = nullptr;
 }
 
 HTMLFormElement* HTMLConstructionSite::takeForm() {
   return m_form.release();
 }
 
 void HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML(
     AtomicHTMLToken* token) {
-  ASSERT(m_document);
+  DCHECK(m_document);
   HTMLHtmlElement* element = HTMLHtmlElement::create(*m_document);
   setAttributes(element, token, m_parserContentPolicy);
   attachLater(m_attachmentRoot, element);
   m_openElements.pushHTMLHtmlElement(HTMLStackItem::create(element, token));
 
   executeQueuedTasks();
   element->insertedByParser();
 }
 
 void HTMLConstructionSite::mergeAttributesFromTokenIntoElement(
@@ skipping 192 matching lines @@
                            TextCaseASCIIInsensitive))) {
     setCompatibilityMode(Document::LimitedQuirksMode);
     return;
   }
 
   // Otherwise we are No Quirks Mode.
   setCompatibilityMode(Document::NoQuirksMode);
 }
 
 void HTMLConstructionSite::processEndOfFile() {
-  ASSERT(currentNode());
+  DCHECK(currentNode());
   flush(FlushAlways);
   openElements()->popAll();
 }
 
 void HTMLConstructionSite::finishedParsing() {
   // We shouldn't have any queued tasks but we might have pending text which we
   // need to promote to tasks and execute.
-  ASSERT(m_taskQueue.isEmpty());
+  DCHECK(m_taskQueue.isEmpty());
   flush(FlushAlways);
   m_document->finishedParsing();
 }
 
 void HTMLConstructionSite::insertDoctype(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::DOCTYPE);
+  DCHECK_EQ(token->type(), HTMLToken::DOCTYPE);
 
   const String& publicId =
       StringImpl::create8BitIfPossible(token->publicIdentifier());
   const String& systemId =
       StringImpl::create8BitIfPossible(token->systemIdentifier());
   DocumentType* doctype =
       DocumentType::create(m_document, token->name(), publicId, systemId);
   attachLater(m_attachmentRoot, doctype);
 
   // DOCTYPE nodes are only processed when parsing fragments w/o
   // contextElements, which never occurs.  However, if we ever chose to support
   // such, this code is subtly wrong, because context-less fragments can
   // determine their own quirks mode, and thus change parsing rules (like <p>
   // inside <table>).  For now we ASSERT that we never hit this code in a
   // fragment, as changing the owning document's compatibility mode would be
   // wrong.
-  ASSERT(!m_isParsingFragment);
+  DCHECK(!m_isParsingFragment);
   if (m_isParsingFragment)
     return;
 
   if (token->forceQuirks())
     setCompatibilityMode(Document::QuirksMode);
   else {
     setCompatibilityModeFromDoctype(token->name(), publicId, systemId);
   }
 }
 
 void HTMLConstructionSite::insertComment(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::Comment);
+  DCHECK_EQ(token->type(), HTMLToken::Comment);
   attachLater(currentNode(),
               Comment::create(ownerDocumentForCurrentNode(), token->comment()));
 }
 
 void HTMLConstructionSite::insertCommentOnDocument(AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::Comment);
-  ASSERT(m_document);
+  DCHECK_EQ(token->type(), HTMLToken::Comment);
+  DCHECK(m_document);
   attachLater(m_attachmentRoot, Comment::create(*m_document, token->comment()));
 }
 
 void HTMLConstructionSite::insertCommentOnHTMLHtmlElement(
     AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::Comment);
+  DCHECK_EQ(token->type(), HTMLToken::Comment);
   ContainerNode* parent = m_openElements.rootNode();
   attachLater(parent, Comment::create(parent->document(), token->comment()));
 }
 
 void HTMLConstructionSite::insertHTMLHeadElement(AtomicHTMLToken* token) {
-  ASSERT(!shouldFosterParent());
+  DCHECK(!shouldFosterParent());
   m_head = HTMLStackItem::create(createHTMLElement(token), token);
   attachLater(currentNode(), m_head->element());
   m_openElements.pushHTMLHeadElement(m_head);
 }
 
 void HTMLConstructionSite::insertHTMLBodyElement(AtomicHTMLToken* token) {
-  ASSERT(!shouldFosterParent());
+  DCHECK(!shouldFosterParent());
   HTMLElement* body = createHTMLElement(token);
   attachLater(currentNode(), body);
   m_openElements.pushHTMLBodyElement(HTMLStackItem::create(body, token));
   if (m_document)
     m_document->willInsertBody();
 }
 
 void HTMLConstructionSite::insertHTMLFormElement(AtomicHTMLToken* token,
                                                  bool isDemoted) {
   HTMLElement* element = createHTMLElement(token);
-  ASSERT(isHTMLFormElement(element));
+  DCHECK(isHTMLFormElement(element));
   HTMLFormElement* formElement = toHTMLFormElement(element);
   if (!openElements()->hasTemplateInHTMLScope())
     m_form = formElement;
   formElement->setDemoted(isDemoted);
   attachLater(currentNode(), formElement);
   m_openElements.push(HTMLStackItem::create(formElement, token));
 }
 
 void HTMLConstructionSite::insertHTMLElement(AtomicHTMLToken* token) {
   HTMLElement* element = createHTMLElement(token);
   attachLater(currentNode(), element);
   m_openElements.push(HTMLStackItem::create(element, token));
 }
 
 void HTMLConstructionSite::insertSelfClosingHTMLElementDestroyingToken(
     AtomicHTMLToken* token) {
-  ASSERT(token->type() == HTMLToken::StartTag);
+  DCHECK_EQ(token->type(), HTMLToken::StartTag);
   // Normally HTMLElementStack is responsible for calling finishParsingChildren,
   // but self-closing elements are never in the element stack so the stack
   // doesn't get a chance to tell them that we're done parsing their children.
   attachLater(currentNode(), createHTMLElement(token), true);
   // FIXME: Do we want to acknowledge the token's self-closing flag?
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#acknowledge-self-closing-flag
 }
 
 void HTMLConstructionSite::insertFormattingElement(AtomicHTMLToken* token) {
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#the-stack-of-open-elements
@@ skipping 27 matching lines @@
                                 alreadyStarted, createdDuringDocumentWrite);
   setAttributes(element, token, m_parserContentPolicy);
   if (scriptingContentIsAllowed(m_parserContentPolicy))
     attachLater(currentNode(), element);
   m_openElements.push(HTMLStackItem::create(element, token));
 }
 
 void HTMLConstructionSite::insertForeignElement(
     AtomicHTMLToken* token,
     const AtomicString& namespaceURI) {
-  ASSERT(token->type() == HTMLToken::StartTag);
+  DCHECK_EQ(token->type(), HTMLToken::StartTag);
   // parseError when xmlns or xmlns:xlink are wrong.
   DVLOG(1) << "Not implemented.";
 
   Element* element = createElement(token, namespaceURI);
   if (scriptingContentIsAllowed(m_parserContentPolicy) ||
       !element->isScriptElement()) {
     attachLater(currentNode(), element, token->selfClosing());
   }
   if (!token->selfClosing())
     m_openElements.push(HTMLStackItem::create(element, token, namespaceURI));
@@ skipping 224 matching lines @@
   firstUnopenElementIndex = index;
   return true;
 }
 
 void HTMLConstructionSite::reconstructTheActiveFormattingElements() {
   unsigned firstUnopenElementIndex;
   if (!indexOfFirstUnopenFormattingElement(firstUnopenElementIndex))
     return;
 
   unsigned unopenEntryIndex = firstUnopenElementIndex;
-  ASSERT(unopenEntryIndex < m_activeFormattingElements.size());
+  DCHECK_LT(unopenEntryIndex, m_activeFormattingElements.size());
   for (; unopenEntryIndex < m_activeFormattingElements.size();
        ++unopenEntryIndex) {
     HTMLFormattingElementList::Entry& unopenedEntry =
         m_activeFormattingElements.at(unopenEntryIndex);
     HTMLStackItem* reconstructed =
         createElementFromSavedToken(unopenedEntry.stackItem());
     attachLater(currentNode(), reconstructed->node());
     m_openElements.push(reconstructed);
     unopenedEntry.replaceElement(reconstructed);
   }
@@ skipping 54 matching lines @@
 bool HTMLConstructionSite::shouldFosterParent() const {
   return m_redirectAttachToFosterParent &&
          currentStackItem()->isElementNode() &&
          currentStackItem()->causesFosterParenting();
 }
 
 void HTMLConstructionSite::fosterParent(Node* node) {
   HTMLConstructionSiteTask task(HTMLConstructionSiteTask::Insert);
   findFosterSite(task);
   task.child = node;
-  ASSERT(task.parent);
+  DCHECK(task.parent);
   queueTask(task);
 }
 
 DEFINE_TRACE(HTMLConstructionSite::PendingText) {
   visitor->trace(parent);
   visitor->trace(nextChild);
 }
 
 }  // namespace blink