Revert of 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
@@ skipping 23 matching lines @@
 #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/html/parser/TokenizedChunkQueue.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,
-                    TaskRunnerHelper::get(TaskType::Networking, &document))
+              ? HTMLParserScheduler::create(this, m_loadingTaskRunner.get())
               : 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));
   // 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());
   }
 
-  m_backgroundParser.clear();
+  if (m_haveBackgroundParser)
+    stopBackgroundParser();
   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();
   }
-  m_backgroundParser.clear();
+  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_backgroundParser);
+  ASSERT(!hasInsertionPoint() || m_haveBackgroundParser);
 
   // NOTE: This pump should only ever emit buffered character tokens.
   if (m_tokenizer) {
-    ASSERT(!m_backgroundParser);
+    ASSERT(!m_haveBackgroundParser);
     pumpTokenizerIfPossible();
   }
 
   if (isStopped())
     return;
 
   DocumentParser::prepareToStopParsing();
 
   // We will not have a scriptRunner when parsing a DocumentFragment.
   if (m_scriptRunner)
@@ skipping 19 matching lines @@
   pumpTokenizer();
 }
 
 bool HTMLDocumentParser::isScheduledForResume() const {
   return m_parserScheduler && m_parserScheduler->isScheduledForResume();
 }
 
 // Used by HTMLParserScheduler
 void HTMLDocumentParser::resumeParsingAfterYield() {
   ASSERT(shouldUseThreading());
-  ASSERT(m_backgroundParser);
+  ASSERT(m_haveBackgroundParser);
 
   checkIfBodyStylesheetAdded();
   if (isStopped() || isPaused())
     return;
 
   pumpPendingSpeculations();
 }
 
 void HTMLDocumentParser::runScriptsForPausedTreeBuilder() {
   ASSERT(scriptingContentIsAllowed(getParserContentPolicy()));
@@ skipping 106 matching lines @@
   if (!isPaused() && !isScheduledForResume()) {
     if (m_tasksWereSuspended)
       m_parserScheduler->forceResumeAfterYield();
     else
       m_parserScheduler->scheduleForResume();
   }
 }
 
 void HTMLDocumentParser::didReceiveEncodingDataFromBackgroundParser(
     const DocumentEncodingData& data) {
-  if (!isParsing())
-    return;
   document()->setEncodingData(data);
 }
 
 void HTMLDocumentParser::validateSpeculations(
     std::unique_ptr<TokenizedChunk> chunk) {
   ASSERT(chunk);
   // TODO(kouhei): We should simplify codepath here by disallowing
   // validateSpeculations
   // while isPaused, and m_lastChunkBeforePause can simply be
   // pushed to m_speculations.
@@ skipping 33 matching lines @@
   }
 
   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_backgroundParser->resumeFrom(std::move(checkpoint));
+  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(!isPaused());
   ASSERT(!isStopped());
   ASSERT(shouldUseThreading());
   ASSERT(!m_tokenizer);
   ASSERT(!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_backgroundParser->startedChunkWithCheckpoint(chunk->inputCheckpoint);
+  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());
 
     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) {
-        // There should never be any chunks after the EOF.
-        ASSERT(m_speculations.isEmpty());
+        ASSERT(
+            m_speculations
+                .isEmpty());  // There should never be any chunks after the EOF.
         prepareToStopParsing();
       }
       break;
     }
 
     m_textPosition = it->textPosition();
 
     constructTreeFromCompactHTMLToken(*it);
 
     if (isStopped())
@@ skipping 93 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_backgroundParser)
+    if (!m_haveBackgroundParser)
       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() {
@@ skipping 119 matching lines @@
 
 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_backgroundParser || wasCreatedByScript());
+    ASSERT(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_backgroundParser);
+  ASSERT(!m_haveBackgroundParser);
   ASSERT(document());
+  m_haveBackgroundParser = true;
 
-  // TODO(csharrison): Remove WebFrameScheduler::setDocumentParsingInBackground.
+  // 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())
     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());
 
+  // The background parser is created on the main thread, but may otherwise
+  // only be used from the parser thread.
   m_backgroundParser =
-      BackgroundHTMLParser::create(this, *document(), std::move(config));
+      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();
 }
 
 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());
 
@@ skipping 36 matching lines @@
 
   pumpTokenizerIfPossible();
 
   endIfDelayed();
 }
 
 void HTMLDocumentParser::end() {
   ASSERT(!isDetached());
   ASSERT(!isScheduledForResume());
 
-  m_backgroundParser.clear();
+  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());
   // 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_backgroundParser);
+  ASSERT(!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 20 matching lines @@
   // 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_backgroundParser) {
+  if (m_haveBackgroundParser) {
     if (!m_input.haveSeenEndOfFile())
       m_input.closeWithoutMarkingEndOfFile();
-    m_backgroundParser->finish();
+    m_loadingTaskRunner->postTask(
+        BLINK_FROM_HERE,
+        WTF::bind(&BackgroundHTMLParser::finish, m_backgroundParser));
     return;
   }
 
   if (!m_tokenizer) {
     ASSERT(!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);
   }
@@ skipping 12 matching lines @@
     return false;
   return m_scriptRunner->isExecutingScript();
 }
 
 bool HTMLDocumentParser::isParsingAtLineNumber() const {
   return m_isParsingAtLineNumber &&
          ScriptableDocumentParser::isParsingAtLineNumber();
 }
 
 OrdinalNumber HTMLDocumentParser::lineNumber() const {
-  if (m_backgroundParser)
+  if (m_haveBackgroundParser)
     return m_textPosition.m_line;
 
   return m_input.current().currentLine();
 }
 
 TextPosition HTMLDocumentParser::textPosition() const {
-  if (m_backgroundParser)
+  if (m_haveBackgroundParser)
     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 {
@@ skipping 16 matching lines @@
 }
 
 void HTMLDocumentParser::resumeParsingAfterPause() {
   ASSERT(!isExecutingScript());
   DCHECK(!isPaused());
 
   checkIfBodyStylesheetAdded();
   if (isPaused())
     return;
 
-  if (m_backgroundParser) {
+  if (m_haveBackgroundParser) {
     if (m_lastChunkBeforePause) {
       validateSpeculations(std::move(m_lastChunkBeforePause));
       DCHECK(!m_lastChunkBeforePause);
       pumpPendingSpeculations();
     }
     return;
   }
 
   m_insertionPreloadScanner.reset();
   if (m_tokenizer) {
@@ skipping 92 matching lines @@
   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_backgroundParser)
+    if (!m_haveBackgroundParser)
       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_backgroundParser->appendRawBytesFromMainThread(std::move(buffer),
-                                                     bytesReceivedTime);
+    m_loadingTaskRunner->postTask(
+        BLINK_FROM_HERE,
+        WTF::bind(&BackgroundHTMLParser::appendRawBytesFromMainThread,
+                  m_backgroundParser, WTF::passed(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_backgroundParser) {
+    if (!m_haveBackgroundParser) {
       m_shouldUseThreading = false;
       m_token = WTF::wrapUnique(new HTMLToken);
       m_tokenizer = HTMLTokenizer::create(m_options);
       DecodedDataDocumentParser::flush();
       return;
     }
-    m_backgroundParser->flush();
+
+    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);
   DecodedDataDocumentParser::setDecoder(std::move(decoder));
 
-  if (m_backgroundParser)
-    m_backgroundParser->setDecoder(takeDecoder());
+  if (m_haveBackgroundParser) {
+    m_loadingTaskRunner->postTask(
+        BLINK_FROM_HERE,
+        WTF::bind(&BackgroundHTMLParser::setDecoder, m_backgroundParser,
+                  WTF::passed(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