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

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

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 135 matching lines @@
       m_shouldUseThreading(syncPolicy == AllowAsynchronousParsing),
       m_endWasDelayed(false),
       m_haveBackgroundParser(false),
       m_tasksWereSuspended(false),
       m_pumpSessionNestingLevel(0),
       m_pumpSpeculationsSessionNestingLevel(0),
       m_isParsingAtLineNumber(false),
       m_triedLoadingLinkHeaders(false),
       m_addedPendingStylesheetInBody(false),
       m_isWaitingForStylesheets(false) {
-  ASSERT(shouldUseThreading() || (m_token && m_tokenizer));
+  DCHECK(shouldUseThreading() || (m_token && m_tokenizer));
   // Threading is not allowed in prefetch mode.
   DCHECK(!document.isPrefetchOnly() || !shouldUseThreading());
 }
 
 HTMLDocumentParser::~HTMLDocumentParser() {}
 
 void HTMLDocumentParser::dispose() {
   // In Oilpan, HTMLDocumentParser can die together with Document, and detach()
   // is not called in this case.
   if (m_haveBackgroundParser)
@@ skipping 53 matching lines @@
   }
   if (m_haveBackgroundParser)
     stopBackgroundParser();
 }
 
 // This kicks off "Once the user agent stops parsing" as described by:
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#the-end
 void HTMLDocumentParser::prepareToStopParsing() {
   // FIXME: It may not be correct to disable this for the background parser.
   // That means hasInsertionPoint() may not be correct in some cases.
-  ASSERT(!hasInsertionPoint() || m_haveBackgroundParser);
+  DCHECK(!hasInsertionPoint() || m_haveBackgroundParser);
 
   // NOTE: This pump should only ever emit buffered character tokens.
   if (m_tokenizer) {
-    ASSERT(!m_haveBackgroundParser);
+    DCHECK(!m_haveBackgroundParser);
     pumpTokenizerIfPossible();
   }
 
   if (isStopped())
     return;
 
   DocumentParser::prepareToStopParsing();
 
   // We will not have a scriptRunner when parsing a DocumentFragment.
   if (m_scriptRunner)
@@ skipping 18 matching lines @@
 
   pumpTokenizer();
 }
 
 bool HTMLDocumentParser::isScheduledForResume() const {
   return m_parserScheduler && m_parserScheduler->isScheduledForResume();
 }
 
 // Used by HTMLParserScheduler
 void HTMLDocumentParser::resumeParsingAfterYield() {
-  ASSERT(shouldUseThreading());
-  ASSERT(m_haveBackgroundParser);
+  DCHECK(shouldUseThreading());
+  DCHECK(m_haveBackgroundParser);
 
   checkIfBodyStylesheetAdded();
   if (isStopped() || isPaused())
     return;
 
   pumpPendingSpeculations();
 }
 
 void HTMLDocumentParser::runScriptsForPausedTreeBuilder() {
-  ASSERT(scriptingContentIsAllowed(getParserContentPolicy()));
+  DCHECK(scriptingContentIsAllowed(getParserContentPolicy()));
 
   TextPosition scriptStartPosition = TextPosition::belowRangePosition();
   Element* scriptElement =
       m_treeBuilder->takeScriptToProcess(scriptStartPosition);
   // We will not have a scriptRunner when parsing a DocumentFragment.
   if (m_scriptRunner)
     m_scriptRunner->processScriptElement(scriptElement, scriptStartPosition);
   checkIfBodyStylesheetAdded();
 }
 
@@ skipping 58 matching lines @@
       for (auto& request : chunk->preloads) {
         // Link rel preloads don't need to wait for AppCache but they
         // should probably wait for CSP.
         if (!m_pendingCSPMetaToken && request->isLinkRelPreload())
           linkRelPreloads.push_back(std::move(request));
         else
           m_queuedPreloads.push_back(std::move(request));
       }
       for (auto& index : chunk->likelyDocumentWriteScriptIndices) {
         const CompactHTMLToken& token = chunk->tokens->at(index);
-        ASSERT(token.type() == HTMLToken::TokenType::Character);
+        DCHECK_EQ(token.type(), HTMLToken::TokenType::Character);
         m_queuedDocumentWriteScripts.push_back(token.data());
       }
     }
     m_preloader->takeAndPreload(linkRelPreloads);
   } else {
     // We can safely assume that there are no queued preloads request after the
     // document element is available, as we empty the queue immediately after
     // the document element is created in documentElementAvailable().
-    ASSERT(m_queuedPreloads.isEmpty());
-    ASSERT(m_queuedDocumentWriteScripts.isEmpty());
+    DCHECK(m_queuedPreloads.isEmpty());
+    DCHECK(m_queuedDocumentWriteScripts.isEmpty());
     // Loop through the chunks to generate preloads before any document.write
     // script evaluation takes place. Preloading these scripts is valuable and
     // comparably cheap, while evaluating JS can be expensive.
     for (auto& chunk : pendingChunks)
       m_preloader->takeAndPreload(chunk->preloads);
     for (auto& chunk : pendingChunks) {
       for (auto& index : chunk->likelyDocumentWriteScriptIndices) {
         const CompactHTMLToken& token = chunk->tokens->at(index);
-        ASSERT(token.type() == HTMLToken::TokenType::Character);
+        DCHECK_EQ(token.type(), HTMLToken::TokenType::Character);
         evaluateAndPreloadScriptForDocumentWrite(token.data());
       }
     }
   }
 
   for (auto& chunk : pendingChunks)
     m_speculations.push_back(std::move(chunk));
 
   if (!isPaused() && !isScheduledForResume()) {
     if (m_tasksWereSuspended)
       m_parserScheduler->forceResumeAfterYield();
     else
       m_parserScheduler->scheduleForResume();
   }
 }
 
 void HTMLDocumentParser::didReceiveEncodingDataFromBackgroundParser(
     const DocumentEncodingData& data) {
   document()->setEncodingData(data);
 }
 
 void HTMLDocumentParser::validateSpeculations(
     std::unique_ptr<TokenizedChunk> chunk) {
-  ASSERT(chunk);
+  DCHECK(chunk);
   // TODO(kouhei): We should simplify codepath here by disallowing
   // validateSpeculations
   // while isPaused, and m_lastChunkBeforePause can simply be
   // pushed to m_speculations.
   if (isPaused()) {
     // We're waiting on a network script or stylesheet, just save the chunk,
     // we'll get a second validateSpeculations call after the script or
     // stylesheet completes. This call should have been made immediately after
     // runScriptsForPausedTreeBuilder in the script case which may have started
     // a network load and left us waiting.
@@ skipping 15 matching lines @@
   // Currently we're only smart enough to reuse the speculation buffer if the
   // tokenizer both starts and ends in the DataState. That state is simplest
   // because the HTMLToken is always in the Uninitialized state. We should
   // consider whether we can reuse the speculation buffer in other states, but
   // we'd likely need to do something more sophisticated with the HTMLToken.
   if (chunk->tokenizerState == HTMLTokenizer::DataState &&
       tokenizer->getState() == HTMLTokenizer::DataState &&
       m_input.current().isEmpty() &&
       chunk->treeBuilderState ==
           HTMLTreeBuilderSimulator::stateFor(m_treeBuilder.get())) {
-    ASSERT(token->isUninitialized());
+    DCHECK(token->isUninitialized());
     return;
   }
 
   discardSpeculationsAndResumeFrom(std::move(chunk), std::move(token),
                                    std::move(tokenizer));
 }
 
 void HTMLDocumentParser::discardSpeculationsAndResumeFrom(
     std::unique_ptr<TokenizedChunk> lastChunkBeforeScript,
     std::unique_ptr<HTMLToken> token,
@@ skipping 19 matching lines @@
   checkpoint->tokenizer = std::move(tokenizer);
   checkpoint->treeBuilderState =
       HTMLTreeBuilderSimulator::stateFor(m_treeBuilder.get());
   checkpoint->inputCheckpoint = lastChunkBeforeScript->inputCheckpoint;
   checkpoint->preloadScannerCheckpoint =
       lastChunkBeforeScript->preloadScannerCheckpoint;
   checkpoint->unparsedInput = m_input.current().toString().isolatedCopy();
   // FIXME: This should be passed in instead of cleared.
   m_input.current().clear();
 
-  ASSERT(checkpoint->unparsedInput.isSafeToSendToAnotherThread());
+  DCHECK(checkpoint->unparsedInput.isSafeToSendToAnotherThread());
   m_loadingTaskRunner->postTask(
       BLINK_FROM_HERE,
       WTF::bind(&BackgroundHTMLParser::resumeFrom, m_backgroundParser,
                 WTF::passed(std::move(checkpoint))));
 }
 
 size_t HTMLDocumentParser::processTokenizedChunkFromBackgroundParser(
     std::unique_ptr<TokenizedChunk> popChunk) {
   TRACE_EVENT_WITH_FLOW0(
       "blink,loading",
       "HTMLDocumentParser::processTokenizedChunkFromBackgroundParser",
       popChunk.get(), TRACE_EVENT_FLAG_FLOW_IN);
   AutoReset<bool> hasLineNumber(&m_isParsingAtLineNumber, true);
 
   SECURITY_DCHECK(m_pumpSpeculationsSessionNestingLevel == 1);
   SECURITY_DCHECK(!inPumpSession());
-  ASSERT(!isParsingFragment());
+  DCHECK(!isParsingFragment());
   DCHECK(!isPaused());
-  ASSERT(!isStopped());
-  ASSERT(shouldUseThreading());
-  ASSERT(!m_tokenizer);
-  ASSERT(!m_token);
+  DCHECK(!isStopped());
+  DCHECK(shouldUseThreading());
+  DCHECK(!m_tokenizer);
+  DCHECK(!m_token);
   DCHECK(!m_lastChunkBeforePause);
 
   std::unique_ptr<TokenizedChunk> chunk(std::move(popChunk));
   std::unique_ptr<CompactHTMLTokenStream> tokens = std::move(chunk->tokens);
   size_t elementTokenCount = 0;
 
   m_loadingTaskRunner->postTask(
       BLINK_FROM_HERE,
       WTF::bind(&BackgroundHTMLParser::startedChunkWithCheckpoint,
                 m_backgroundParser, chunk->inputCheckpoint));
 
   for (const auto& xssInfo : chunk->xssInfos) {
     m_textPosition = xssInfo->m_textPosition;
     m_xssAuditorDelegate.didBlockScript(*xssInfo);
     if (isStopped())
       break;
   }
   // XSSAuditorDelegate can detach the parser if it decides to block the entire
   // current document.
   if (isDetached())
     return elementTokenCount;
 
   for (Vector<CompactHTMLToken>::const_iterator it = tokens->begin();
        it != tokens->end(); ++it) {
-    ASSERT(!isWaitingForScripts());
+    DCHECK(!isWaitingForScripts());
 
     if (!chunk->startingScript &&
         (it->type() == HTMLToken::StartTag || it->type() == HTMLToken::EndTag))
       elementTokenCount++;
 
     if (document()->frame() &&
         document()->frame()->navigationScheduler().locationChangePending()) {
       // To match main-thread parser behavior (which never checks
       // locationChangePending on the EOF path) we peek to see if this chunk has
       // an EOF and process it anyway.
       if (tokens->back().type() == HTMLToken::EndOfFile) {
-        ASSERT(
+        DCHECK(
             m_speculations
                 .isEmpty());  // There should never be any chunks after the EOF.
         prepareToStopParsing();
       }
       break;
     }
 
     m_textPosition = it->textPosition();
 
     constructTreeFromCompactHTMLToken(*it);
 
     if (isStopped())
       break;
 
     // Preloads were queued if there was a <meta> csp token in a tokenized
     // chunk.
     if (m_pendingCSPMetaToken && it == m_pendingCSPMetaToken) {
       m_pendingCSPMetaToken = nullptr;
       fetchQueuedPreloads();
     }
 
     if (isPaused()) {
       // The script or stylesheet should be the last token of this bunch.
-      ASSERT(it + 1 == tokens->end());
+      DCHECK_EQ(it + 1, tokens->end());
       if (isWaitingForScripts())
         runScriptsForPausedTreeBuilder();
       validateSpeculations(std::move(chunk));
       break;
     }
 
     if (it->type() == HTMLToken::EndOfFile) {
       // The EOF is assumed to be the last token of this bunch.
-      ASSERT(it + 1 == tokens->end());
+      DCHECK_EQ(it + 1, tokens->end());
       // There should never be any chunks after the EOF.
-      ASSERT(m_speculations.isEmpty());
+      DCHECK(m_speculations.isEmpty());
       prepareToStopParsing();
       break;
     }
 
-    ASSERT(!m_tokenizer);
-    ASSERT(!m_token);
+    DCHECK(!m_tokenizer);
+    DCHECK(!m_token);
   }
 
   // Make sure all required pending text nodes are emitted before returning.
   // This leaves "script", "style" and "svg" nodes text nodes intact.
   if (!isStopped())
     m_treeBuilder->flush(FlushIfAtTextLimit);
 
   m_isParsingAtLineNumber = false;
 
   return elementTokenCount;
 }
 
 void HTMLDocumentParser::pumpPendingSpeculations() {
   // If this assert fails, you need to call validateSpeculations to make sure
   // m_tokenizer and m_token don't have state that invalidates m_speculations.
-  ASSERT(!m_tokenizer);
-  ASSERT(!m_token);
+  DCHECK(!m_tokenizer);
+  DCHECK(!m_token);
   DCHECK(!m_lastChunkBeforePause);
   DCHECK(!isPaused());
-  ASSERT(!isStopped());
-  ASSERT(!isScheduledForResume());
-  ASSERT(!inPumpSession());
+  DCHECK(!isStopped());
+  DCHECK(!isScheduledForResume());
+  DCHECK(!inPumpSession());
 
   // FIXME: Here should never be reached when there is a blocking script,
   // but it happens in unknown scenarios. See https://crbug.com/440901
   if (isWaitingForScripts()) {
     m_parserScheduler->scheduleForResume();
     return;
   }
 
   // Do not allow pumping speculations in nested event loops.
   if (m_pumpSpeculationsSessionNestingLevel) {
     m_parserScheduler->scheduleForResume();
     return;
   }
 
   probe::ParseHTML probe(document(), this);
 
   SpeculationsPumpSession session(m_pumpSpeculationsSessionNestingLevel);
   while (!m_speculations.isEmpty()) {
-    ASSERT(!isScheduledForResume());
+    DCHECK(!isScheduledForResume());
     size_t elementTokenCount =
         processTokenizedChunkFromBackgroundParser(m_speculations.takeFirst());
     session.addedElementTokens(elementTokenCount);
 
     // Always check isParsing first as m_document may be null. Surprisingly,
     // isScheduledForResume() may be set here as a result of
     // processTokenizedChunkFromBackgroundParser running arbitrary javascript
     // which invokes nested event loops. (e.g. inspector breakpoints)
     checkIfBodyStylesheetAdded();
     if (!isParsing() || isPaused() || isScheduledForResume())
@@ skipping 14 matching lines @@
       startBackgroundParser();
 
     // This task should be synchronous, because otherwise synchronous
     // tokenizing can happen before plaintext is forced.
     m_backgroundParser->forcePlaintextForTextDocument();
   } else
     m_tokenizer->setState(HTMLTokenizer::PLAINTEXTState);
 }
 
 void HTMLDocumentParser::pumpTokenizer() {
-  ASSERT(!isStopped());
-  ASSERT(m_tokenizer);
-  ASSERT(m_token);
+  DCHECK(!isStopped());
+  DCHECK(m_tokenizer);
+  DCHECK(m_token);
 
   PumpSession session(m_pumpSessionNestingLevel);
 
   // We tell the InspectorInstrumentation about every pump, even if we end up
   // pumping nothing.  It can filter out empty pumps itself.
   // FIXME: m_input.current().length() is only accurate if we end up parsing the
   // whole buffer in this pump.  We should pass how much we parsed as part of
   // didWriteHTML instead of willWriteHTML.
   TRACE_EVENT_BEGIN1(
       "devtools.timeline", "ParseHTML", "beginData",
@@ skipping 20 matching lines @@
                   token(), m_sourceTracker, m_tokenizer->shouldAllowCDATA()))) {
         m_xssAuditorDelegate.didBlockScript(*xssInfo);
         // If we're in blocking mode, we might stop the parser in
         // 'didBlockScript()'. In that case, exit early.
         if (!isParsing())
           return;
       }
     }
 
     constructTreeFromHTMLToken();
-    ASSERT(isStopped() || token().isUninitialized());
+    DCHECK(isStopped() || token().isUninitialized());
   }
 
   if (isStopped())
     return;
 
   // There should only be PendingText left since the tree-builder always flushes
   // the task queue before returning. In case that ever changes, crash.
   m_treeBuilder->flush(FlushAlways);
-  RELEASE_ASSERT(!isStopped());
+  CHECK(!isStopped());
 
   if (isPaused()) {
-    ASSERT(m_tokenizer->getState() == HTMLTokenizer::DataState);
+    DCHECK_EQ(m_tokenizer->getState(), HTMLTokenizer::DataState);
 
-    ASSERT(m_preloader);
+    DCHECK(m_preloader);
     // TODO(kouhei): m_preloader should be always available for synchronous
     // parsing case, adding paranoia if for speculative crash fix for
     // crbug.com/465478
     if (m_preloader) {
       if (!m_preloadScanner) {
         m_preloadScanner = createPreloadScanner();
         m_preloadScanner->appendToEnd(m_input.current());
       }
       scanAndPreload(m_preloadScanner.get());
     }
@@ skipping 21 matching lines @@
     token().clear();
 
   m_treeBuilder->constructTree(&atomicToken);
   checkIfBodyStylesheetAdded();
 
   // FIXME: constructTree may synchronously cause Document to be detached.
   if (!m_token)
     return;
 
   if (!token().isUninitialized()) {
-    ASSERT(token().type() == HTMLToken::Character);
+    DCHECK_EQ(token().type(), HTMLToken::Character);
     token().clear();
   }
 }
 
 void HTMLDocumentParser::constructTreeFromCompactHTMLToken(
     const CompactHTMLToken& compactToken) {
   AtomicHTMLToken token(compactToken);
   m_treeBuilder->constructTree(&token);
   checkIfBodyStylesheetAdded();
 }
 
 bool HTMLDocumentParser::hasInsertionPoint() {
   // FIXME: The wasCreatedByScript() branch here might not be fully correct. Our
   // model of the EOF character differs slightly from the one in the spec
   // because our treatment is uniform between network-sourced and script-sourced
   // input streams whereas the spec treats them differently.
   return m_input.hasInsertionPoint() ||
          (wasCreatedByScript() && !m_input.haveSeenEndOfFile());
 }
 
 void HTMLDocumentParser::insert(const SegmentedString& source) {
   if (isStopped())
     return;
 
   TRACE_EVENT1("blink", "HTMLDocumentParser::insert", "source_length",
                source.length());
 
   if (!m_tokenizer) {
-    ASSERT(!inPumpSession());
-    ASSERT(m_haveBackgroundParser || wasCreatedByScript());
+    DCHECK(!inPumpSession());
+    DCHECK(m_haveBackgroundParser || wasCreatedByScript());
     m_token = WTF::wrapUnique(new HTMLToken);
     m_tokenizer = HTMLTokenizer::create(m_options);
   }
 
   SegmentedString excludedLineNumberSource(source);
   excludedLineNumberSource.setExcludeLineNumbers();
   m_input.insertAtCurrentInsertionPoint(excludedLineNumberSource);
   pumpTokenizerIfPossible();
 
   if (isPaused()) {
     // Check the document.write() output with a separate preload scanner as
     // the main scanner can't deal with insertions.
     if (!m_insertionPreloadScanner)
       m_insertionPreloadScanner = createPreloadScanner();
     m_insertionPreloadScanner->appendToEnd(source);
     scanAndPreload(m_insertionPreloadScanner.get());
   }
 
   endIfDelayed();
 }
 
 void HTMLDocumentParser::startBackgroundParser() {
-  ASSERT(!isStopped());
-  ASSERT(shouldUseThreading());
-  ASSERT(!m_haveBackgroundParser);
-  ASSERT(document());
+  DCHECK(!isStopped());
+  DCHECK(shouldUseThreading());
+  DCHECK(!m_haveBackgroundParser);
+  DCHECK(document());
   m_haveBackgroundParser = true;
 
   // TODO(alexclarke): Remove WebFrameScheduler::setDocumentParsingInBackground
   // when background parser goes away.
   if (document()->frame() && document()->frame()->frameScheduler())
     document()->frame()->frameScheduler()->setDocumentParsingInBackground(true);
 
   // Make sure that a resolver is set up, so that the correct viewport
   // dimensions will be fed to the background parser and preload scanner.
   if (document()->loader())
@@ skipping 16 matching lines @@
           document()
               ->settings()
               ->getBackgroundHtmlParserOutstandingTokenLimit();
     }
     if (document()->settings()->getBackgroundHtmlParserPendingTokenLimit()) {
       config->pendingTokenLimit =
           document()->settings()->getBackgroundHtmlParserPendingTokenLimit();
     }
   }
 
-  ASSERT(config->xssAuditor->isSafeToSendToAnotherThread());
+  DCHECK(config->xssAuditor->isSafeToSendToAnotherThread());
 
   // The background parser is created on the main thread, but may otherwise
   // only be used from the parser thread.
   m_backgroundParser =
       BackgroundHTMLParser::create(std::move(config), m_loadingTaskRunner);
   // TODO(csharrison): This is a hack to initialize MediaValuesCached on the
   // correct thread. We should get rid of it.
   m_backgroundParser->init(
       document()->url(), CachedDocumentParameters::create(document()),
       MediaValuesCached::MediaValuesCachedData(*document()));
 }
 
 void HTMLDocumentParser::stopBackgroundParser() {
-  ASSERT(shouldUseThreading());
-  ASSERT(m_haveBackgroundParser);
+  DCHECK(shouldUseThreading());
+  DCHECK(m_haveBackgroundParser);
 
   if (m_haveBackgroundParser && document()->frame() &&
       document()->frame()->frameScheduler())
     document()->frame()->frameScheduler()->setDocumentParsingInBackground(
         false);
 
   m_haveBackgroundParser = false;
 
   // Make this sync, as lsan triggers on some unittests if the task runner is
   // used.
   m_backgroundParser->stop();
   m_weakFactory.revokeAll();
 }
 
 void HTMLDocumentParser::append(const String& inputSource) {
   if (isStopped())
     return;
 
   // We should never reach this point if we're using a parser thread, as
   // appendBytes() will directly ship the data to the thread.
-  ASSERT(!shouldUseThreading());
+  DCHECK(!shouldUseThreading());
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.debug"),
                "HTMLDocumentParser::append", "size", inputSource.length());
   const SegmentedString source(inputSource);
 
   if (document()->isPrefetchOnly()) {
     if (!m_preloadScanner)
       m_preloadScanner = createPreloadScanner();
 
     m_preloadScanner->appendToEnd(source);
@@ skipping 24 matching lines @@
     // this data in a less-nested write().
     return;
   }
 
   pumpTokenizerIfPossible();
 
   endIfDelayed();
 }
 
 void HTMLDocumentParser::end() {
-  ASSERT(!isDetached());
-  ASSERT(!isScheduledForResume());
+  DCHECK(!isDetached());
+  DCHECK(!isScheduledForResume());
 
   if (m_haveBackgroundParser)
     stopBackgroundParser();
 
   // Informs the the rest of WebCore that parsing is really finished (and
   // deletes this).
   m_treeBuilder->finished();
 
   DocumentParser::stopParsing();
 }
 
 void HTMLDocumentParser::attemptToRunDeferredScriptsAndEnd() {
-  ASSERT(isStopping());
+  DCHECK(isStopping());
   // FIXME: It may not be correct to disable this for the background parser.
   // That means hasInsertionPoint() may not be correct in some cases.
-  ASSERT(!hasInsertionPoint() || m_haveBackgroundParser);
+  DCHECK(!hasInsertionPoint() || m_haveBackgroundParser);
   if (m_scriptRunner && !m_scriptRunner->executeScriptsWaitingForParsing())
     return;
   end();
 }
 
 void HTMLDocumentParser::attemptToEnd() {
   // finish() indicates we will not receive any more data. If we are waiting on
   // an external script to load, we can't finish parsing quite yet.
 
   if (shouldDelayEnd()) {
@@ skipping 30 matching lines @@
   if (m_haveBackgroundParser) {
     if (!m_input.haveSeenEndOfFile())
       m_input.closeWithoutMarkingEndOfFile();
     m_loadingTaskRunner->postTask(
         BLINK_FROM_HERE,
         WTF::bind(&BackgroundHTMLParser::finish, m_backgroundParser));
     return;
   }
 
   if (!m_tokenizer) {
-    ASSERT(!m_token);
+    DCHECK(!m_token);
     // We're finishing before receiving any data. Rather than booting up the
     // background parser just to spin it down, we finish parsing synchronously.
     m_token = WTF::wrapUnique(new HTMLToken);
     m_tokenizer = HTMLTokenizer::create(m_options);
   }
 
   // We're not going to get any more data off the network, so we tell the input
   // stream we've reached the end of file. finish() can be called more than
   // once, if the first time does not call end().
   if (!m_input.haveSeenEndOfFile())
@@ skipping 37 matching lines @@
   // the script runner. The script runner will hold the script until its loaded
   // and run. During any of this time, we want to count ourselves as "waiting
   // for a script" and thus run the preload scanner, as well as delay completion
   // of parsing.
   bool treeBuilderHasBlockingScript = m_treeBuilder->hasParserBlockingScript();
   bool scriptRunnerHasBlockingScript =
       m_scriptRunner && m_scriptRunner->hasParserBlockingScript();
   // Since the parser is paused while a script runner has a blocking script, it
   // should never be possible to end up with both objects holding a blocking
   // script.
-  ASSERT(!(treeBuilderHasBlockingScript && scriptRunnerHasBlockingScript));
+  DCHECK(!(treeBuilderHasBlockingScript && scriptRunnerHasBlockingScript));
   // If either object has a blocking script, the parser should be paused.
   return treeBuilderHasBlockingScript || scriptRunnerHasBlockingScript ||
          m_reentryPermit->parserPauseFlag();
 }
 
 void HTMLDocumentParser::resumeParsingAfterPause() {
-  ASSERT(!isExecutingScript());
+  DCHECK(!isExecutingScript());
   DCHECK(!isPaused());
 
   checkIfBodyStylesheetAdded();
   if (isPaused())
     return;
 
   if (m_haveBackgroundParser) {
     if (m_lastChunkBeforePause) {
       validateSpeculations(std::move(m_lastChunkBeforePause));
       DCHECK(!m_lastChunkBeforePause);
       pumpPendingSpeculations();
     }
     return;
   }
 
   m_insertionPreloadScanner.reset();
   if (m_tokenizer) {
     pumpTokenizerIfPossible();
   }
   endIfDelayed();
 }
 
 void HTMLDocumentParser::appendCurrentInputStreamToPreloadScannerAndScan() {
-  ASSERT(m_preloadScanner);
+  DCHECK(m_preloadScanner);
   m_preloadScanner->appendToEnd(m_input.current());
   scanAndPreload(m_preloadScanner.get());
 }
 
 void HTMLDocumentParser::notifyScriptLoaded(PendingScript* pendingScript) {
-  ASSERT(m_scriptRunner);
-  ASSERT(!isExecutingScript());
+  DCHECK(m_scriptRunner);
+  DCHECK(!isExecutingScript());
 
   if (isStopped()) {
     return;
   }
 
   if (isStopping()) {
     attemptToRunDeferredScriptsAndEnd();
     return;
   }
 
@@ skipping 49 matching lines @@
     ParserContentPolicy parserContentPolicy) {
   HTMLDocumentParser* parser =
       HTMLDocumentParser::create(fragment, contextElement, parserContentPolicy);
   parser->append(source);
   parser->finish();
   // Allows ~DocumentParser to assert it was detached before destruction.
   parser->detach();
 }
 
 void HTMLDocumentParser::suspendScheduledTasks() {
-  ASSERT(!m_tasksWereSuspended);
+  DCHECK(!m_tasksWereSuspended);
   m_tasksWereSuspended = true;
   if (m_parserScheduler)
     m_parserScheduler->suspend();
 }
 
 void HTMLDocumentParser::resumeScheduledTasks() {
-  ASSERT(m_tasksWereSuspended);
+  DCHECK(m_tasksWereSuspended);
   m_tasksWereSuspended = false;
   if (m_parserScheduler)
     m_parserScheduler->resume();
 }
 
 void HTMLDocumentParser::appendBytes(const char* data, size_t length) {
   if (!length || isStopped())
     return;
 
   if (shouldUseThreading()) {
@@ skipping 37 matching lines @@
     m_loadingTaskRunner->postTask(
         BLINK_FROM_HERE,
         WTF::bind(&BackgroundHTMLParser::flush, m_backgroundParser));
   } else {
     DecodedDataDocumentParser::flush();
   }
 }
 
 void HTMLDocumentParser::setDecoder(
     std::unique_ptr<TextResourceDecoder> decoder) {
-  ASSERT(decoder);
+  DCHECK(decoder);
   DecodedDataDocumentParser::setDecoder(std::move(decoder));
 
   if (m_haveBackgroundParser) {
     m_loadingTaskRunner->postTask(
         BLINK_FROM_HERE,
         WTF::bind(&BackgroundHTMLParser::setDecoder, m_backgroundParser,
                   WTF::passed(takeDecoder())));
   }
 }
 
@@ skipping 79 matching lines @@
     successHistogram.count(duration);
   } else {
     DEFINE_STATIC_LOCAL(
         CustomCountHistogram, failureHistogram,
         ("PreloadScanner.DocumentWrite.ExecutionTime.Failure", 1, 10000, 50));
     failureHistogram.count(duration);
   }
 }
 
 }  // namespace blink