Enable ParseHTMLOnMainThread on TOT

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 463 matching lines @@
   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());
-  postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::resumeFrom,
-                            m_backgroundParser,
-                            WTF::passed(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;
 
-  postTaskToLookaheadParser(Asynchronous,
-                            &BackgroundHTMLParser::startedChunkWithCheckpoint,
-                            m_backgroundParser, 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())
@@ skipping 127 matching lines @@
 
 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)
       startBackgroundParser();
 
     // This task should be synchronous, because otherwise synchronous
     // tokenizing can happen before plaintext is forced.
-    postTaskToLookaheadParser(
-        Synchronous, &BackgroundHTMLParser::forcePlaintextForTextDocument,
-        m_backgroundParser);
+    m_backgroundParser->forcePlaintextForTextDocument();
   } else
     m_tokenizer->setState(HTMLTokenizer::PLAINTEXTState);
 }
 
 void HTMLDocumentParser::pumpTokenizer() {
   ASSERT(!isStopped());
   ASSERT(m_tokenizer);
   ASSERT(m_token);
 
   PumpSession session(m_pumpSessionNestingLevel);
@@ skipping 175 matching lines @@
             ->getBackgroundHtmlParserOutstandingTokenLimit()) {
       config->outstandingTokenLimit =
           document()
               ->settings()
               ->getBackgroundHtmlParserOutstandingTokenLimit();
     }
     if (document()->settings()->getBackgroundHtmlParserPendingTokenLimit()) {
       config->pendingTokenLimit =
           document()->settings()->getBackgroundHtmlParserPendingTokenLimit();
     }
-    config->shouldCoalesceChunks =
-        document()->settings()->getParseHTMLOnMainThreadCoalesceChunks();
   }
 
   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(std::move(config), m_loadingTaskRunner);
   // TODO(csharrison): This is a hack to initialize MediaValuesCached on the
   // correct thread. We should get rid of it.
-  postTaskToLookaheadParser(
-      Synchronous, &BackgroundHTMLParser::init, m_backgroundParser,
-      document()->url(),
-      WTF::passed(CachedDocumentParameters::create(document())),
+  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. Note that these lifetimes will be much more concrete if
-  // ParseHTMLOnMainThread lands (the lookahead parser will be a member).
-  postTaskToLookaheadParser(Synchronous, &BackgroundHTMLParser::stop,
-                            m_backgroundParser);
+  // 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 95 matching lines @@
   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_input.haveSeenEndOfFile())
       m_input.closeWithoutMarkingEndOfFile();
-    postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::finish,
-                              m_backgroundParser);
+    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 178 matching lines @@
     double bytesReceivedTime = monotonicallyIncreasingTimeMS();
     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);
 
-    LookaheadParserTaskSynchrony policy =
-        document()->settings() &&
-                document()->settings()->getParseHTMLOnMainThreadSyncTokenize()
-            ? Synchronous
-            : Asynchronous;
-    postTaskToLookaheadParser(
-        policy, &BackgroundHTMLParser::appendRawBytesFromMainThread,
-        m_backgroundParser, WTF::passed(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_haveBackgroundParser) {
       m_shouldUseThreading = false;
       m_token = WTF::wrapUnique(new HTMLToken);
       m_tokenizer = HTMLTokenizer::create(m_options);
       DecodedDataDocumentParser::flush();
       return;
     }
 
-    postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::flush,
-                              m_backgroundParser);
+    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_haveBackgroundParser) {
-    postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::setDecoder,
-                              m_backgroundParser, WTF::passed(takeDecoder()));
+    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() {
@@ skipping 71 matching lines @@
         ("PreloadScanner.DocumentWrite.ExecutionTime.Success", 1, 10000, 50));
     successHistogram.count(duration);
   } else {
     DEFINE_STATIC_LOCAL(
         CustomCountHistogram, failureHistogram,
         ("PreloadScanner.DocumentWrite.ExecutionTime.Failure", 1, 10000, 50));
     failureHistogram.count(duration);
   }
 }
 
-template <typename FunctionType, typename... Ps>
-void HTMLDocumentParser::postTaskToLookaheadParser(
-    LookaheadParserTaskSynchrony synchronyPolicy,
-    FunctionType function,
-    Ps&&... parameters) {
-  if (!RuntimeEnabledFeatures::parseHTMLOnMainThreadEnabled()) {
-    HTMLParserThread::shared()->postTask(
-        crossThreadBind(function, std::forward<Ps>(parameters)...));
-    return;
-  }
-
-  // Some messages to the lookahead parser should be synchronous. Otherwise,
-  // just post to the loading task runner.
-  switch (synchronyPolicy) {
-    case Synchronous:
-      (*WTF::bind(function, std::forward<Ps>(parameters)...))();
-      return;
-    case Asynchronous:
-      m_loadingTaskRunner->postTask(
-          BLINK_FROM_HERE,
-          WTF::bind(function, std::forward<Ps>(parameters)...));
-      return;
-  }
-  NOTREACHED();
-}
-
 }  // namespace blink