ParseHTMLOnMainThread: notify main thread of chunks less frequently

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

 /*
  * Copyright (C) 2013 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 75 matching lines @@
 
 void BackgroundHTMLParser::start(PassRefPtr<WeakReference<BackgroundHTMLParser>> reference, std::unique_ptr<Configuration> config, const KURL& documentURL, std::unique_ptr<CachedDocumentParameters> cachedDocumentParameters, const MediaValuesCached::MediaValuesCachedData& mediaValuesCachedData, std::unique_ptr<WebTaskRunner> loadingTaskRunner)
 {
     new BackgroundHTMLParser(reference, std::move(config), documentURL, std::move(cachedDocumentParameters), mediaValuesCachedData, std::move(loadingTaskRunner));
     // Caller must free by calling stop().
 }
 
 BackgroundHTMLParser::Configuration::Configuration()
     : outstandingTokenLimit(defaultOutstandingTokenLimit)
     , pendingTokenLimit(defaultPendingTokenLimit)
+    , shouldCoalesceChunks(false)
 {
 }
 
 BackgroundHTMLParser::BackgroundHTMLParser(PassRefPtr<WeakReference<BackgroundHTMLParser>> reference, std::unique_ptr<Configuration> config, const KURL& documentURL, std::unique_ptr<CachedDocumentParameters> cachedDocumentParameters, const MediaValuesCached::MediaValuesCachedData& mediaValuesCachedData, std::unique_ptr<WebTaskRunner> loadingTaskRunner)
     : m_weakFactory(reference, this)
     , m_token(wrapUnique(new HTMLToken))
     , m_tokenizer(HTMLTokenizer::create(config->options))
     , m_treeBuilderSimulator(config->options)
     , m_options(config->options)
     , m_outstandingTokenLimit(config->outstandingTokenLimit)
     , m_parser(config->parser)
     , m_pendingTokens(wrapUnique(new CompactHTMLTokenStream))
     , m_pendingTokenLimit(config->pendingTokenLimit)
     , m_xssAuditor(std::move(config->xssAuditor))
     , m_preloadScanner(wrapUnique(new TokenPreloadScanner(documentURL, std::move(cachedDocumentParameters), mediaValuesCachedData)))
     , m_decoder(std::move(config->decoder))
     , m_loadingTaskRunner(std::move(loadingTaskRunner))
     , m_tokenizedChunkQueue(config->tokenizedChunkQueue.release())
     , m_startingScript(false)
     , m_lastBytesReceivedTime(0.0)
+    , m_shouldCoalesceChunks(config->shouldCoalesceChunks)
 {
     ASSERT(m_outstandingTokenLimit > 0);
     ASSERT(m_pendingTokenLimit > 0);
     ASSERT(m_outstandingTokenLimit >= m_pendingTokenLimit);
 }
 
 BackgroundHTMLParser::~BackgroundHTMLParser()
 {
 }
 
@@ skipping 92 matching lines @@
 
 void BackgroundHTMLParser::pumpTokenizer()
 {
     TRACE_EVENT0("loading", "BackgroundHTMLParser::pumpTokenizer");
     HTMLTreeBuilderSimulator::SimulatedToken simulatedToken = HTMLTreeBuilderSimulator::OtherToken;
 
     // No need to start speculating until the main thread has almost caught up.
     if (m_input.totalCheckpointTokenCount() > m_outstandingTokenLimit)
         return;
 
+    bool shouldNotifyMainThread = false;
     while (true) {
         if (m_xssAuditor->isEnabled())
             m_sourceTracker.start(m_input.current(), m_tokenizer.get(), *m_token);
 
         if (!m_tokenizer->nextToken(m_input.current(), *m_token)) {
             // We've reached the end of our current input.
-            sendTokensToMainThread();
+            shouldNotifyMainThread |= queueChunkForMainThread();
             break;
         }
 
         if (m_xssAuditor->isEnabled())
             m_sourceTracker.end(m_input.current(), m_tokenizer.get(), *m_token);
 
         {
             TextPosition position = TextPosition(m_input.current().currentLine(), m_input.current().currentColumn());
 
             if (std::unique_ptr<XSSInfo> xssInfo = m_xssAuditor->filterToken(FilterTokenRequest(*m_token, m_sourceTracker, m_tokenizer->shouldAllowCDATA()))) {
                 xssInfo->m_textPosition = position;
                 m_pendingXSSInfos.append(std::move(xssInfo));
             }
 
             CompactHTMLToken token(m_token.get(), position);
 
             bool shouldEvaluateForDocumentWrite = false;
             m_preloadScanner->scan(token, m_input.current(), m_pendingPreloads, &m_viewportDescription, &shouldEvaluateForDocumentWrite);
 
             simulatedToken = m_treeBuilderSimulator.simulate(token, m_tokenizer.get());
 
             // Break chunks before a script tag is inserted and flag the chunk as starting a script
             // so the main parser can decide if it should yield before processing the chunk.
             if (simulatedToken == HTMLTreeBuilderSimulator::ScriptStart) {
-                sendTokensToMainThread();
+                shouldNotifyMainThread |= queueChunkForMainThread();
                 m_startingScript = true;
             }
 
             m_pendingTokens->append(token);
             if (shouldEvaluateForDocumentWrite) {
                 m_likelyDocumentWriteScriptIndices.append(m_pendingTokens->size() - 1);
             }
         }
 
         m_token->clear();
 
         if (simulatedToken == HTMLTreeBuilderSimulator::ScriptEnd || m_pendingTokens->size() >= m_pendingTokenLimit) {
-            sendTokensToMainThread();
+            shouldNotifyMainThread |= queueChunkForMainThread();
             // If we're far ahead of the main thread, yield for a bit to avoid consuming too much memory.
             if (m_input.totalCheckpointTokenCount() > m_outstandingTokenLimit)
                 break;
         }
+
+        if (!m_shouldCoalesceChunks && shouldNotifyMainThread) {
+            runOnMainThread(&HTMLDocumentParser::notifyPendingTokenizedChunks, m_parser);
+            shouldNotifyMainThread = false;
+        }
+    }
+    // Wait to notify the main thread about the chunks until we're at the
+    // limit. This lets the background parser generate lots of valuable
+    // preloads before anything expensive (extensions, scripts) take up time
+    // on the main thread. A busy main thread can cause preload delays.
+    if (shouldNotifyMainThread) {
+        runOnMainThread(&HTMLDocumentParser::notifyPendingTokenizedChunks, m_parser);
     }
 }
 
-void BackgroundHTMLParser::sendTokensToMainThread()
+bool BackgroundHTMLParser::queueChunkForMainThread()
 {
     if (m_pendingTokens->isEmpty())
-        return;
+        return false;
 
 #if ENABLE(ASSERT)
     checkThatTokensAreSafeToSendToAnotherThread(m_pendingTokens.get());
     checkThatPreloadsAreSafeToSendToAnotherThread(m_pendingPreloads);
     checkThatXSSInfosAreSafeToSendToAnotherThread(m_pendingXSSInfos);
 #endif
 
     double chunkStartTime = monotonicallyIncreasingTimeMS();
     std::unique_ptr<HTMLDocumentParser::TokenizedChunk> chunk = wrapUnique(new HTMLDocumentParser::TokenizedChunk);
     TRACE_EVENT_WITH_FLOW0("blink,loading", "BackgroundHTMLParser::sendTokensToMainThread", chunk.get(), TRACE_EVENT_FLAG_FLOW_OUT);
@@ skipping 15 matching lines @@
     chunk->tokens = std::move(m_pendingTokens);
     chunk->startingScript = m_startingScript;
     chunk->likelyDocumentWriteScriptIndices.swap(m_likelyDocumentWriteScriptIndices);
     m_startingScript = false;
 
     bool isEmpty = m_tokenizedChunkQueue->enqueue(std::move(chunk));
 
     DEFINE_STATIC_LOCAL(CustomCountHistogram, chunkEnqueueTime, ("Parser.ChunkEnqueueTime", 1, 10000, 50));
     chunkEnqueueTime.count(monotonicallyIncreasingTimeMS() - chunkStartTime);
 
-    if (isEmpty) {
-        runOnMainThread(&HTMLDocumentParser::notifyPendingTokenizedChunks, m_parser);
-    }
 
     m_pendingTokens = wrapUnique(new CompactHTMLTokenStream);
+    return isEmpty;
 }
 
 // If the background parser is already running on the main thread, then it is
 // not necessary to post a task to the main thread to run asynchronously. The
 // main parser deals with chunking up its own work.
 // TODO(csharrison): This is a pretty big hack because we don't actually need a
 // CrossThreadClosure in these cases. This is just experimental.
 template <typename FunctionType, typename... Ps>
 void BackgroundHTMLParser::runOnMainThread(FunctionType function, Ps&&... parameters)
 {
     if (isMainThread()) {
         (*WTF::bind(function, std::forward<Ps>(parameters)...))();
     } else {
         m_loadingTaskRunner->postTask(BLINK_FROM_HERE, crossThreadBind(function, std::forward<Ps>(parameters)...));
     }
 }
 
 } // namespace blink