Put the BackgroundHTMLParser on oilpan heap

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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY GOOGLE 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 GOOGLE 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/BackgroundHTMLParser.h"
 
+#include <memory>

[Yoav Weiss, 2017/02/09 10:39:00]

Do you know why is <memory> included both here and in the h file? I know you
just moved it around, but can we get rid of it altogether?

[Charlie Harrison, 2017/02/13 22:55:31]

It is for unique_ptr

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

Yeah, but I'd love to see it *only* in the h, and not re-included in the cpp.
Anyway, this is not unique to this patch, and I know some people prefer it this
way. I'll argue against it elsewhere :)

[Charlie Harrison, 2017/02/15 03:00:07]

Oh, no that is completely fair. I completely misread your comment, apologies.
Removed.

 #include "core/HTMLNames.h"
+#include "core/dom/Document.h"
+#include "core/dom/TaskRunnerHelper.h"
 #include "core/html/parser/HTMLDocumentParser.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "core/html/parser/XSSAuditor.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/Histogram.h"
 #include "platform/WebTaskRunner.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/Functional.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/TextPosition.h"
-#include <memory>
 
 namespace blink {
 
 // On a network with high latency and high bandwidth, using a device with a fast
 // CPU, we could end up speculatively tokenizing the whole document, well ahead
 // of when the main-thread actually needs it. This is a waste of memory (and
 // potentially time if the speculation fails). So we limit our outstanding
 // tokens arbitrarily to 10,000. Our maximal memory spent speculating will be
 // approximately:
 // (defaultOutstandingTokenLimit + defaultPendingTokenLimit) *
@@ skipping 27 matching lines @@
 }
 
 static void checkThatXSSInfosAreSafeToSendToAnotherThread(
     const XSSInfoStream& infos) {
   for (size_t i = 0; i < infos.size(); ++i)
     ASSERT(infos[i]->isSafeToSendToAnotherThread());
 }
 
 #endif
 
-WeakPtr<BackgroundHTMLParser> BackgroundHTMLParser::create(
-    std::unique_ptr<Configuration> config,
-    RefPtr<WebTaskRunner> loadingTaskRunner) {
-  auto* backgroundParser =
-      new BackgroundHTMLParser(std::move(config), std::move(loadingTaskRunner));
-  return backgroundParser->m_weakFactory.createWeakPtr();
+BackgroundHTMLParser* BackgroundHTMLParser::create(
+    HTMLDocumentParser* parser,
+    Document& document,
+    std::unique_ptr<Configuration> config) {
+  return new BackgroundHTMLParser(
+      parser, std::move(config),
+      TaskRunnerHelper::get(TaskType::Networking, &document),
+      WTF::makeUnique<TokenPreloadScanner>(
+          document.url(), CachedDocumentParameters::create(&document),
+          MediaValuesCached::MediaValuesCachedData(document)));
 }
 
-void BackgroundHTMLParser::init(
-    const KURL& documentURL,
-    std::unique_ptr<CachedDocumentParameters> cachedDocumentParameters,
-    const MediaValuesCached::MediaValuesCachedData& mediaValuesCachedData) {
-  m_preloadScanner.reset(new TokenPreloadScanner(
-      documentURL, std::move(cachedDocumentParameters), mediaValuesCachedData));
+DEFINE_TRACE(BackgroundHTMLParser) {
+  visitor->trace(m_parser);
 }
 
 BackgroundHTMLParser::Configuration::Configuration()
     : outstandingTokenLimit(defaultOutstandingTokenLimit),
       pendingTokenLimit(defaultPendingTokenLimit),
       shouldCoalesceChunks(false) {}
 
 BackgroundHTMLParser::BackgroundHTMLParser(
+    HTMLDocumentParser* parser,
     std::unique_ptr<Configuration> config,
-    RefPtr<WebTaskRunner> loadingTaskRunner)
-    : m_weakFactory(this),
-      m_token(WTF::wrapUnique(new HTMLToken)),
+    RefPtr<WebTaskRunner> loadingTaskRunner,
+    std::unique_ptr<TokenPreloadScanner> scanner)
+    : m_token(WTF::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_parser(parser),
       m_pendingTokens(WTF::wrapUnique(new CompactHTMLTokenStream)),
       m_pendingTokenLimit(config->pendingTokenLimit),
       m_xssAuditor(std::move(config->xssAuditor)),
+      m_preloadScanner(std::move(scanner)),
       m_decoder(std::move(config->decoder)),
       m_loadingTaskRunner(std::move(loadingTaskRunner)),
       m_tokenizedChunkQueue(std::move(config->tokenizedChunkQueue)),
       m_pendingCSPMetaTokenIndex(
           HTMLDocumentParser::TokenizedChunk::noPendingToken),
       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() {}
 
 void BackgroundHTMLParser::appendRawBytesFromMainThread(
     std::unique_ptr<Vector<char>> buffer,
     double bytesReceivedTime) {
   ASSERT(m_decoder);
   m_lastBytesReceivedTime = bytesReceivedTime;
   DEFINE_STATIC_LOCAL(CustomCountHistogram, queueDelay,
                       ("Parser.AppendBytesDelay", 1, 5000, 50));
   queueDelay.count(monotonicallyIncreasingTimeMS() - bytesReceivedTime);
-  updateDocument(m_decoder->decode(buffer->data(), buffer->size()));
+  m_loadingTaskRunner->postTask(
+      BLINK_FROM_HERE,
+      WTF::bind(&BackgroundHTMLParser::updateDocument, wrapPersistent(this),
+                m_decoder->decode(buffer->data(), buffer->size())));
 }
 
 void BackgroundHTMLParser::appendDecodedBytes(const String& input) {
   ASSERT(!m_input.current().isClosed());
   m_input.append(input);
   pumpTokenizer();
 }
 
 void BackgroundHTMLParser::setDecoder(
     std::unique_ptr<TextResourceDecoder> decoder) {
   ASSERT(decoder);
   m_decoder = std::move(decoder);
 }
 
 void BackgroundHTMLParser::flush() {
   ASSERT(m_decoder);
-  updateDocument(m_decoder->flush());
+  m_loadingTaskRunner->postTask(
+      BLINK_FROM_HERE, WTF::bind(&BackgroundHTMLParser::updateDocument,
+                                 wrapPersistent(this), m_decoder->flush()));
 }
 
 void BackgroundHTMLParser::updateDocument(const String& decodedData) {
   DocumentEncodingData encodingData(*m_decoder.get());
 
   if (encodingData != m_lastSeenEncodingData) {
     m_lastSeenEncodingData = encodingData;
 
     m_xssAuditor->setEncoding(encodingData.encoding());
-    runOnMainThread(
-        &HTMLDocumentParser::didReceiveEncodingDataFromBackgroundParser,
-        m_parser, encodingData);
+    m_parser->didReceiveEncodingDataFromBackgroundParser(encodingData);
   }
 
   if (decodedData.isEmpty())
     return;
 
   appendDecodedBytes(decodedData);
 }
 
 void BackgroundHTMLParser::resumeFrom(std::unique_ptr<Checkpoint> checkpoint) {
-  m_parser = checkpoint->parser;
+  m_loadingTaskRunner->postTask(
+      BLINK_FROM_HERE,
+      WTF::bind(&BackgroundHTMLParser::onResumeFrom, wrapPersistent(this),
+                WTF::passed(std::move(checkpoint))));

[Yoav Weiss, 2017/02/09 10:39:00]

Is this switch from sync to async calls related to the oilpan change?

[Charlie Harrison, 2017/02/13 22:55:32]

No, I'm also moving the postTasks from outside the background html parser to
within it. If you want, I can revert those changes and go back to the old
behavior.

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

You can leave it as part of this patch 

+}
+
+void BackgroundHTMLParser::onResumeFrom(
+    std::unique_ptr<Checkpoint> checkpoint) {
   m_token = std::move(checkpoint->token);
   m_tokenizer = std::move(checkpoint->tokenizer);
   m_treeBuilderSimulator.setState(checkpoint->treeBuilderState);
   m_input.rewindTo(checkpoint->inputCheckpoint, checkpoint->unparsedInput);
   m_preloadScanner->rewindTo(checkpoint->preloadScannerCheckpoint);
   m_startingScript = false;
   m_tokenizedChunkQueue->clear();
   m_lastBytesReceivedTime = monotonicallyIncreasingTimeMS();
   pumpTokenizer();
 }
 
 void BackgroundHTMLParser::startedChunkWithCheckpoint(
     HTMLInputCheckpoint inputCheckpoint) {
   // Note, we should not have to worry about the index being invalid as messages
   // from the main thread will be processed in FIFO order.
   m_input.invalidateCheckpointsBefore(inputCheckpoint);
+  m_loadingTaskRunner->postTask(
+      BLINK_FROM_HERE,
+      WTF::bind(&BackgroundHTMLParser::pumpTokenizer, wrapPersistent(this)));
+}
+
+void BackgroundHTMLParser::onFinish() {
+  markEndOfFile();
   pumpTokenizer();
 }
 
 void BackgroundHTMLParser::finish() {
-  markEndOfFile();
-  pumpTokenizer();
-}
-
-void BackgroundHTMLParser::stop() {
-  delete this;
+  m_loadingTaskRunner->postTask(
+      BLINK_FROM_HERE,
+      WTF::bind(&BackgroundHTMLParser::onFinish, wrapPersistent(this)));
 }
 
 void BackgroundHTMLParser::forcePlaintextForTextDocument() {
   // This is only used by the TextDocumentParser (a subclass of
   // HTMLDocumentParser) to force us into the PLAINTEXT state w/o using a
   // <plaintext> tag. The TextDocumentParser uses a <pre> tag for historical /
   // compatibility reasons.
   m_tokenizer->setState(HTMLTokenizer::PLAINTEXTState);
 }
 
@@ skipping 73 matching lines @@
         simulatedToken == HTMLTreeBuilderSimulator::Link ||
         m_pendingTokens->size() >= m_pendingTokenLimit) {
       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);
+      m_parser->notifyPendingTokenizedChunks();
       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);
+    m_parser->notifyPendingTokenizedChunks();
   }
 }
 
 bool BackgroundHTMLParser::queueChunkForMainThread() {
   if (m_pendingTokens->isEmpty())
     return false;
 
 #if DCHECK_IS_ON()
   checkThatTokensAreSafeToSendToAnotherThread(m_pendingTokens.get());
   checkThatPreloadsAreSafeToSendToAnotherThread(m_pendingPreloads);
@@ skipping 34 matching lines @@
   bool isEmpty = m_tokenizedChunkQueue->enqueue(std::move(chunk));
 
   DEFINE_STATIC_LOCAL(CustomCountHistogram, chunkEnqueueTime,
                       ("Parser.ChunkEnqueueTime", 1, 10000, 50));
   chunkEnqueueTime.count(monotonicallyIncreasingTimeMS() - chunkStartTime);
 
   m_pendingTokens = WTF::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