Put the BackgroundHTMLParser on oilpan heap

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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/html/parser/HTMLDocumentParser.h"
 
+#include <memory>
 #include "bindings/core/v8/DocumentWriteEvaluator.h"
 #include "core/HTMLNames.h"
 #include "core/css/MediaValuesCached.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/Element.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLDocument.h"
 #include "core/html/parser/AtomicHTMLToken.h"
 #include "core/html/parser/BackgroundHTMLParser.h"
 #include "core/html/parser/HTMLParserScheduler.h"
 #include "core/html/parser/HTMLParserScriptRunner.h"
 #include "core/html/parser/HTMLResourcePreloader.h"
 #include "core/html/parser/HTMLTreeBuilder.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/LinkLoader.h"
 #include "core/loader/NavigationScheduler.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/Histogram.h"
 #include "platform/SharedBuffer.h"
 #include "platform/WebFrameScheduler.h"
 #include "platform/heap/Handle.h"
+#include "platform/heap/Persistent.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebLoadingBehaviorFlag.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "wtf/AutoReset.h"
 #include "wtf/PtrUtil.h"
-#include <memory>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 // This is a direct transcription of step 4 from:
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#fragment-case
 static HTMLTokenizer::State tokenizerStateForContextElement(
     Element* contextElement,
     bool reportErrors,
@@ skipping 51 matching lines @@
                                        ParserSynchronizationPolicy syncPolicy)
     : ScriptableDocumentParser(document, contentPolicy),
       m_options(&document),
       m_reentryPermit(HTMLParserReentryPermit::create()),
       m_token(syncPolicy == ForceSynchronousParsing
                   ? WTF::wrapUnique(new HTMLToken)
                   : nullptr),
       m_tokenizer(syncPolicy == ForceSynchronousParsing
                       ? HTMLTokenizer::create(m_options)
                       : nullptr),
-      m_loadingTaskRunner(
-          TaskRunnerHelper::get(TaskType::Networking, &document)),
       m_parserScheduler(
           syncPolicy == AllowAsynchronousParsing
-              ? HTMLParserScheduler::create(this, m_loadingTaskRunner.get())
+              ? HTMLParserScheduler::create(
+                    this,
+                    TaskRunnerHelper::get(TaskType::Networking, &document))
               : nullptr),
       m_xssAuditorDelegate(&document),
-      m_weakFactory(this),
       m_preloader(HTMLResourcePreloader::create(document)),
       m_tokenizedChunkQueue(TokenizedChunkQueue::create()),
       m_evaluator(DocumentWriteEvaluator::create(document)),
       m_pendingCSPMetaToken(nullptr),
       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)
-    stopBackgroundParser();
-}
-
 DEFINE_TRACE(HTMLDocumentParser) {
   visitor->trace(m_treeBuilder);
   visitor->trace(m_parserScheduler);
   visitor->trace(m_xssAuditorDelegate);
   visitor->trace(m_scriptRunner);
+  visitor->trace(m_backgroundParser);
   visitor->trace(m_preloader);
   ScriptableDocumentParser::trace(visitor);
   HTMLParserScriptRunnerHost::trace(visitor);
 }
 
 void HTMLDocumentParser::detach() {
   if (!isParsingFragment() && m_tokenizedChunkQueue.get() &&
       m_tokenizedChunkQueue->peakPendingChunkCount()) {
     DEFINE_STATIC_LOCAL(CustomCountHistogram, peakPendingChunkHistogram,
                         ("Parser.PeakPendingChunkCount", 1, 1000, 50));
     peakPendingChunkHistogram.count(
         m_tokenizedChunkQueue->peakPendingChunkCount());
     DEFINE_STATIC_LOCAL(CustomCountHistogram, peakPendingTokenHistogram,
                         ("Parser.PeakPendingTokenCount", 1, 100000, 50));
     peakPendingTokenHistogram.count(
         m_tokenizedChunkQueue->peakPendingTokenCount());
   }
 
-  if (m_haveBackgroundParser)
-    stopBackgroundParser();
+  m_backgroundParser.clear();
   DocumentParser::detach();
   if (m_scriptRunner)
     m_scriptRunner->detach();
   m_treeBuilder->detach();
   // FIXME: It seems wrong that we would have a preload scanner here. Yet during
   // fast/dom/HTMLScriptElement/script-load-events.html we do.
   m_preloadScanner.reset();
   m_insertionPreloadScanner.reset();
   if (m_parserScheduler) {
     m_parserScheduler->detach();
     m_parserScheduler.clear();
   }
   // Oilpan: It is important to clear m_token to deallocate backing memory of
   // HTMLToken::m_data and let the allocator reuse the memory for
   // HTMLToken::m_data of a next HTMLDocumentParser. We need to clear
   // m_tokenizer first because m_tokenizer has a raw pointer to m_token.
   m_tokenizer.reset();
   m_token.reset();
 }
 
 void HTMLDocumentParser::stopParsing() {
   DocumentParser::stopParsing();
   if (m_parserScheduler) {
     m_parserScheduler->detach();
     m_parserScheduler.clear();
   }
-  if (m_haveBackgroundParser)
-    stopBackgroundParser();
+  m_backgroundParser.clear();
 }
 
 // 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_backgroundParser);
 
   // NOTE: This pump should only ever emit buffered character tokens.
   if (m_tokenizer) {
-    ASSERT(!m_haveBackgroundParser);
+    DCHECK(!m_backgroundParser);
     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_backgroundParser);
 
   checkIfBodyStlyesheetAdded();
   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);
   checkIfBodyStlyesheetAdded();
 }
 
@@ 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(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(token.type() == HTMLToken::TokenType::Character);
         evaluateAndPreloadScriptForDocumentWrite(token.data());
       }
     }
   }
 
   for (auto& chunk : pendingChunks)
     m_speculations.append(std::move(chunk));
 
   if (!isPaused() && !isScheduledForResume()) {
     if (m_tasksWereSuspended)
       m_parserScheduler->forceResumeAfterYield();
     else
       m_parserScheduler->scheduleForResume();
   }
 }
 
 void HTMLDocumentParser::didReceiveEncodingDataFromBackgroundParser(
     const DocumentEncodingData& data) {
+  if (!isParsing())

[Charlie Harrison, 2017/02/08 23:48:01]

This is necessary because now the bg parser is a member, and doesn't have its
destructor called synchronously (and thus its pending tasks killed due to weak
ptr semantics).

[Yoav Weiss, 2017/02/14 06:45:47]

ok

+    return;
   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,
     std::unique_ptr<HTMLTokenizer> tokenizer) {
-  m_weakFactory.revokeAll();
-
   size_t discardedTokenCount = 0;
   for (const auto& speculation : m_speculations) {
     discardedTokenCount += speculation->tokens->size();
   }
   DEFINE_STATIC_LOCAL(CustomCountHistogram, discardedTokenCountHistogram,
                       ("Parser.DiscardedTokenCount", 1, 100000, 50));
   discardedTokenCountHistogram.count(discardedTokenCount);
 
   m_speculations.clear();
   m_pendingCSPMetaToken = nullptr;
   m_queuedPreloads.clear();
 
   std::unique_ptr<BackgroundHTMLParser::Checkpoint> checkpoint =
       WTF::wrapUnique(new BackgroundHTMLParser::Checkpoint);
-  checkpoint->parser = m_weakFactory.createWeakPtr();
   checkpoint->token = std::move(token);
   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());
-  m_loadingTaskRunner->postTask(
-      BLINK_FROM_HERE,
-      WTF::bind(&BackgroundHTMLParser::resumeFrom, m_backgroundParser,
-                WTF::passed(std::move(checkpoint))));
+  DCHECK(checkpoint->unparsedInput.isSafeToSendToAnotherThread());
+  m_backgroundParser->resumeFrom(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));
+  m_backgroundParser->startedChunkWithCheckpoint(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(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(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;
   }
 
   // FIXME: Pass in current input length.
   TRACE_EVENT_BEGIN1("devtools.timeline", "ParseHTML", "beginData",
                      InspectorParseHtmlEvent::beginData(
                          document(), lineNumber().zeroBasedInt()));
 
   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)
     checkIfBodyStlyesheetAdded();
     if (!isParsing() || isPaused() || isScheduledForResume())
@@ skipping 10 matching lines @@
       InspectorParseHtmlEvent::endData(lineNumber().zeroBasedInt() - 1));
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
                        "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data",
                        InspectorUpdateCountersEvent::data());
 }
 
 void HTMLDocumentParser::forcePlaintextForTextDocument() {
   if (shouldUseThreading()) {
     // This method is called before any data is appended, so we have to start
     // the background parser ourselves.
-    if (!m_haveBackgroundParser)
+    if (!m_backgroundParser)
       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(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);
   checkIfBodyStlyesheetAdded();
 
   // FIXME: constructTree may synchronously cause Document to be detached.
   if (!m_token)
     return;
 
   if (!token().isUninitialized()) {
-    ASSERT(token().type() == HTMLToken::Character);
+    DCHECK(token().type() == HTMLToken::Character);
     token().clear();
   }
 }
 
 void HTMLDocumentParser::constructTreeFromCompactHTMLToken(
     const CompactHTMLToken& compactToken) {
   AtomicHTMLToken token(compactToken);
   m_treeBuilder->constructTree(&token);
   checkIfBodyStlyesheetAdded();
 }
 
 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_backgroundParser || 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());
-  m_haveBackgroundParser = true;
+  DCHECK(!isStopped());
+  DCHECK(shouldUseThreading());
+  DCHECK(!m_backgroundParser);
+  DCHECK(document());
 
-  // TODO(alexclarke): Remove WebFrameScheduler::setDocumentParsingInBackground
-  // when background parser goes away.
+  // TODO(csharrison): Remove WebFrameScheduler::setDocumentParsingInBackground.
   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())
     document()->ensureStyleResolver();
 
   std::unique_ptr<BackgroundHTMLParser::Configuration> config =
       WTF::wrapUnique(new BackgroundHTMLParser::Configuration);
   config->options = m_options;
-  config->parser = m_weakFactory.createWeakPtr();
   config->xssAuditor = WTF::wrapUnique(new XSSAuditor);
   config->xssAuditor->init(document(), &m_xssAuditorDelegate);
 
   config->decoder = takeDecoder();
   config->tokenizedChunkQueue = m_tokenizedChunkQueue.get();
   if (document()->settings()) {
     if (document()
             ->settings()
             ->getBackgroundHtmlParserOutstandingTokenLimit()) {
       config->outstandingTokenLimit =
           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);
-
-  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();
+      BackgroundHTMLParser::create(this, *document(), std::move(config));
 }
 
 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();
+  m_backgroundParser.clear();
 
   // 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_backgroundParser);
   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()) {
     m_endWasDelayed = true;
     return;
   }
   prepareToStopParsing();
 }
 
 void HTMLDocumentParser::endIfDelayed() {
   // If we've already been detached, don't bother ending.
   if (isDetached())
     return;
 
   if (!m_endWasDelayed || shouldDelayEnd())
     return;
 
   m_endWasDelayed = false;
   prepareToStopParsing();
 }
 
 void HTMLDocumentParser::finish() {
-  // FIXME: We should ASSERT(!m_parserStopped) here, since it does not makes
+  // FIXME: We should DCHECK(!m_parserStopped) here, since it does not makes
   // sense to call any methods on DocumentParser once it's been stopped.
   // However, FrameLoader::stop calls DocumentParser::finish unconditionally.
 
   flush();
   if (isDetached())
     return;
 
   // Empty documents never got an append() call, and thus have never started a
   // background parser. In those cases, we ignore shouldUseThreading() and fall
   // through to the non-threading case.
-  if (m_haveBackgroundParser) {
+  if (m_backgroundParser) {
     if (!m_input.haveSeenEndOfFile())
       m_input.closeWithoutMarkingEndOfFile();
-    m_loadingTaskRunner->postTask(
-        BLINK_FROM_HERE,
-        WTF::bind(&BackgroundHTMLParser::finish, m_backgroundParser));
+    m_backgroundParser->finish();
     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())
     m_input.markEndOfFile();
 
   attemptToEnd();
 }
 
 bool HTMLDocumentParser::isExecutingScript() const {
   if (!m_scriptRunner)
     return false;
   return m_scriptRunner->isExecutingScript();
 }
 
 bool HTMLDocumentParser::isParsingAtLineNumber() const {
   return m_isParsingAtLineNumber &&
          ScriptableDocumentParser::isParsingAtLineNumber();
 }
 
 OrdinalNumber HTMLDocumentParser::lineNumber() const {
-  if (m_haveBackgroundParser)
+  if (m_backgroundParser)
     return m_textPosition.m_line;
 
   return m_input.current().currentLine();
 }
 
 TextPosition HTMLDocumentParser::textPosition() const {
-  if (m_haveBackgroundParser)
+  if (m_backgroundParser)
     return m_textPosition;
 
   const SegmentedString& currentString = m_input.current();
   OrdinalNumber line = currentString.currentLine();
   OrdinalNumber column = currentString.currentColumn();
 
   return TextPosition(line, column);
 }
 
 bool HTMLDocumentParser::isWaitingForScripts() const {
   // When the TreeBuilder encounters a </script> tag, it returns to the
   // HTMLDocumentParser where the script is transfered from the treebuilder to
   // 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());
 
   checkIfBodyStlyesheetAdded();
   if (isPaused())
     return;
 
-  if (m_haveBackgroundParser) {
+  if (m_backgroundParser) {
     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()) {
     double bytesReceivedTime = monotonicallyIncreasingTimeMS();
-    if (!m_haveBackgroundParser)
+    if (!m_backgroundParser)
       startBackgroundParser();
 
     std::unique_ptr<Vector<char>> buffer =
         WTF::makeUnique<Vector<char>>(length);
     memcpy(buffer->data(), data, length);
     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.debug"),
                  "HTMLDocumentParser::appendBytes", "size", (unsigned)length);
 
-    m_loadingTaskRunner->postTask(
-        BLINK_FROM_HERE,
-        WTF::bind(&BackgroundHTMLParser::appendRawBytesFromMainThread,
-                  m_backgroundParser, WTF::passed(std::move(buffer)),
-                  bytesReceivedTime));
+    m_backgroundParser->appendRawBytesFromMainThread(std::move(buffer),
+                                                     bytesReceivedTime);
     return;
   }
 
   DecodedDataDocumentParser::appendBytes(data, length);
 }
 
 void HTMLDocumentParser::flush() {
   // If we've got no decoder, we never received any data.
   if (isDetached() || needsDecoder())
     return;
 
   if (shouldUseThreading()) {
     // In some cases, flush() is called without any invocation of appendBytes.
     // Fallback to synchronous parsing in that case.
-    if (!m_haveBackgroundParser) {
+    if (!m_backgroundParser) {
       m_shouldUseThreading = false;
       m_token = WTF::wrapUnique(new HTMLToken);
       m_tokenizer = HTMLTokenizer::create(m_options);
       DecodedDataDocumentParser::flush();
       return;
     }
-
-    m_loadingTaskRunner->postTask(
-        BLINK_FROM_HERE,
-        WTF::bind(&BackgroundHTMLParser::flush, m_backgroundParser));
+    m_backgroundParser->flush();
   } 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())));
-  }
+  if (m_backgroundParser)
+    m_backgroundParser->setDecoder(takeDecoder());
 }
 
 void HTMLDocumentParser::documentElementAvailable() {
   TRACE_EVENT0("blink,loader", "HTMLDocumentParser::documentElementAvailable");
   DCHECK(document()->documentElement());
   fetchQueuedPreloads();
 }
 
 std::unique_ptr<HTMLPreloadScanner> HTMLDocumentParser::createPreloadScanner() {
   return HTMLPreloadScanner::create(
@@ skipping 71 matching lines @@
     successHistogram.count(duration);
   } else {
     DEFINE_STATIC_LOCAL(
         CustomCountHistogram, failureHistogram,
         ("PreloadScanner.DocumentWrite.ExecutionTime.Failure", 1, 10000, 50));
     failureHistogram.count(duration);
   }
 }
 
 }  // namespace blink