Redirect HTML resource bytes directly to parser thread (Blink side CL)

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 15 matching lines @@
 #include "config.h"
 #include "core/html/parser/HTMLDocumentParser.h"
 
 #include "HTMLNames.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/Element.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/HTMLParserThread.h"
 #include "core/html/parser/HTMLScriptRunner.h"
 #include "core/html/parser/HTMLTreeBuilder.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/frame/Frame.h"
+#include "core/loader/DocumentLoader.h"
 #include "platform/SharedBuffer.h"
+#include "platform/Task.h"
 #include "platform/TraceEvent.h"
+#include "public/platform/WebThread.h"
+#include "public/platform/WebThreadedResourceProvider.h"
 #include "wtf/Functional.h"
 
 namespace WebCore {
 
 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, const HTMLParserOptions& options)
 {
@@ skipping 11 matching lines @@
         || (contextTag.matches(noscriptTag) && options.scriptEnabled)
         || contextTag.matches(noframesTag))
         return reportErrors ? HTMLTokenizer::RAWTEXTState : HTMLTokenizer::PLAINTEXTState;
     if (contextTag.matches(scriptTag))
         return reportErrors ? HTMLTokenizer::ScriptDataState : HTMLTokenizer::PLAINTEXTState;
     if (contextTag.matches(plaintextTag))
         return HTMLTokenizer::PLAINTEXTState;
     return HTMLTokenizer::DataState;
 }
 
+class ParserResourceForegroundClient : public blink::WebThreadedResourceForegroundClient {
+public:
+    ParserResourceForegroundClient(WeakPtr<HTMLDocumentParser> parser)
+        : m_parser(parser)
+    {
+    }
+
+    // WebThreadedResourceForegroundClient
+    virtual void didSwitchedToBackgroundClient() OVERRIDE FINAL {

[darin (slow to review), 2014/02/16 07:12:27]

nit: opening paren should be on the next line per blink style.

+        if (m_parser.get())
+            m_parser.get()->didSwitchedToBackgroundClient();

[darin (slow to review), 2014/02/16 07:12:27]

nit: "didSwitched..." should be "didSwitch..."

+    }
+
+private:
+    WeakPtr<HTMLDocumentParser> m_parser;
+};
+
+blink::WebThread* HTMLDocumentParser::s_parserThread = 0;
+
 HTMLDocumentParser::HTMLDocumentParser(HTMLDocument* document, bool reportErrors)
     : ScriptableDocumentParser(document)
     , m_options(document)
     , m_token(m_options.useThreading ? nullptr : adoptPtr(new HTMLToken))
     , m_tokenizer(m_options.useThreading ? nullptr : HTMLTokenizer::create(m_options))
     , m_scriptRunner(HTMLScriptRunner::create(document, this))
     , m_treeBuilder(HTMLTreeBuilder::create(this, document, parserContentPolicy(), reportErrors, m_options))
     , m_parserScheduler(HTMLParserScheduler::create(this))
     , m_xssAuditorDelegate(document)
     , m_weakFactory(this)
     , m_preloader(adoptPtr(new HTMLResourcePreloader(document)))
     , m_isPinnedToMainThread(false)
     , m_endWasDelayed(false)
     , m_haveBackgroundParser(false)
     , m_pumpSessionNestingLevel(0)
+    , m_parserThreadIsStandalone(false)
 {
     ASSERT(shouldUseThreading() || (m_token && m_tokenizer));
 }
 
 // FIXME: Member variables should be grouped into self-initializing structs to
 // minimize code duplication between these constructors.
 HTMLDocumentParser::HTMLDocumentParser(DocumentFragment* fragment, Element* contextElement, ParserContentPolicy parserContentPolicy)
     : ScriptableDocumentParser(&fragment->document(), parserContentPolicy)
     , m_options(&fragment->document())
     , m_token(adoptPtr(new HTMLToken))
     , m_tokenizer(HTMLTokenizer::create(m_options))
     , m_treeBuilder(HTMLTreeBuilder::create(this, fragment, contextElement, this->parserContentPolicy(), m_options))
     , m_xssAuditorDelegate(&fragment->document())
     , m_weakFactory(this)
     , m_isPinnedToMainThread(true)
     , m_endWasDelayed(false)
     , m_haveBackgroundParser(false)
     , m_pumpSessionNestingLevel(0)
+    , m_parserThreadIsStandalone(false)
 {
     ASSERT(!shouldUseThreading());
     bool reportErrors = false; // For now document fragment parsing never reports errors.
     m_tokenizer->setState(tokenizerStateForContextElement(contextElement, reportErrors, m_options));
     m_xssAuditor.initForFragment();
 }
 
 HTMLDocumentParser::~HTMLDocumentParser()
 {
     ASSERT(!m_parserScheduler);
@@ skipping 198 matching lines @@
     chunk->preloads.clear(); // We don't need to preload because we're going to parse immediately.
     m_speculations.append(chunk);
     pumpPendingSpeculations();
 }
 
 void HTMLDocumentParser::didReceiveEncodingDataFromBackgroundParser(const DocumentEncodingData& data)
 {
     document()->setEncodingData(data);
 }
 
+void HTMLDocumentParser::destroyResourceProvider(PassOwnPtr<blink::WebThreadedResourceProvider> resourceProvider)
+{
+    // Here to let the resource bridge be destructed on the main thread.

[darin (slow to review), 2014/02/16 07:12:27]

nit: I think this is a reference to ResourceLoaderBridge which is not something
that is known to Blink. Comments like this may add confusion since it refers to
something outside of the Blink codebase and that something may also disappear in
future revisions of Chromium.

+}
+
 void HTMLDocumentParser::validateSpeculations(PassOwnPtr<ParsedChunk> chunk)
 {
     ASSERT(chunk);
     if (isWaitingForScripts()) {
         // We're waiting on a network script, just save the chunk, we'll get
         // a second validateSpeculations call after the script completes.
         // This call should have been made immediately after runScriptsForPausedTreeBuilder
         // which may have started a network load and left us waiting.
         ASSERT(!m_lastChunkBeforeScript);
         m_lastChunkBeforeScript = chunk;
@@ skipping 35 matching lines @@
     checkpoint->parser = m_weakFactory.createWeakPtr();
     checkpoint->token = token;
     checkpoint->tokenizer = tokenizer;
     checkpoint->treeBuilderState = HTMLTreeBuilderSimulator::stateFor(m_treeBuilder.get());
     checkpoint->inputCheckpoint = lastChunkBeforeScript->inputCheckpoint;
     checkpoint->preloadScannerCheckpoint = lastChunkBeforeScript->preloadScannerCheckpoint;
     checkpoint->unparsedInput = m_input.current().toString().isolatedCopy();
     m_input.current().clear(); // FIXME: This should be passed in instead of cleared.
 
     ASSERT(checkpoint->unparsedInput.isSafeToSendToAnotherThread());
-    HTMLParserThread::shared()->postTask(bind(&BackgroundHTMLParser::resumeFrom, m_backgroundParser, checkpoint.release()));
+    ASSERT(s_parserThread);
+    s_parserThread->postTask(new Task(bind(&BackgroundHTMLParser::resumeFrom, m_backgroundParser, checkpoint.release())));
 }
 
 void HTMLDocumentParser::processParsedChunkFromBackgroundParser(PassOwnPtr<ParsedChunk> popChunk)
 {
     TRACE_EVENT0("webkit", "HTMLDocumentParser::processParsedChunkFromBackgroundParser");
 
     ASSERT_WITH_SECURITY_IMPLICATION(!document()->activeParserCount());
     ASSERT(!isParsingFragment());
     ASSERT(!isWaitingForScripts());
     ASSERT(!isStopped());
     // ASSERT that this object is both attached to the Document and protected.
     ASSERT(refCount() >= 2);
     ASSERT(shouldUseThreading());
     ASSERT(!m_tokenizer);
     ASSERT(!m_token);
     ASSERT(!m_lastChunkBeforeScript);
+    ASSERT(s_parserThread);
 
     ActiveParserSession session(contextForParsingSession());
 
     OwnPtr<ParsedChunk> chunk(popChunk);
     OwnPtr<CompactHTMLTokenStream> tokens = chunk->tokens.release();
 
-    HTMLParserThread::shared()->postTask(bind(&BackgroundHTMLParser::startedChunkWithCheckpoint, m_backgroundParser, chunk->inputCheckpoint));
+    s_parserThread->postTask(new Task(bind(&BackgroundHTMLParser::startedChunkWithCheckpoint, m_backgroundParser, chunk->inputCheckpoint)));
 
     for (XSSInfoStream::const_iterator it = chunk->xssInfos.begin(); it != chunk->xssInfos.end(); ++it) {
         m_textPosition = (*it)->m_textPosition;
         m_xssAuditorDelegate.didBlockScript(**it);
         if (isStopped())
             break;
     }
 
     for (Vector<CompactHTMLToken>::const_iterator it = tokens->begin(); it != tokens->end(); ++it) {
         ASSERT(!isWaitingForScripts());
@@ skipping 70 matching lines @@
             m_parserScheduler->scheduleForResume();
             break;
         }
     }
 
     InspectorInstrumentation::didWriteHTML(cookie, lineNumber().zeroBasedInt());
 }
 
 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();
+    if (shouldUseThreading() && !m_haveBackgroundParser)
+        startBackgroundParser();
 
-        HTMLParserThread::shared()->postTask(bind(&BackgroundHTMLParser::forcePlaintextForTextDocument, m_backgroundParser));
-    } else
+    if (m_haveBackgroundParser)
+        s_parserThread->postTask(new Task(bind(&BackgroundHTMLParser::forcePlaintextForTextDocument, m_backgroundParser)));
+    else
         m_tokenizer->setState(HTMLTokenizer::PLAINTEXTState);
 }
 
 Document* HTMLDocumentParser::contextForParsingSession()
 {
     // The parsing session should interact with the document only when parsing
     // non-fragments. Otherwise, we might delay the load event mistakenly.
     if (isParsingFragment())
         return 0;
     return document();
@@ skipping 143 matching lines @@
     }
 
     endIfDelayed();
 }
 
 void HTMLDocumentParser::startBackgroundParser()
 {
     ASSERT(!isStopped());
     ASSERT(shouldUseThreading());
     ASSERT(!m_haveBackgroundParser);
+
+    OwnPtr<blink::WebThreadedResourceProvider> resourceProvider = document()->loader()->createThreadedResourceProvider();
+    if (resourceProvider) {
+        // The resource provider is responsible for destroying the client we create here.
+        resourceProvider->setForegroundClient(new ParserResourceForegroundClient(m_weakFactory.createWeakPtr()));
+        if (!s_parserThread)
+            s_parserThread = resourceProvider->resourceProviderThread();

[darin (slow to review), 2014/02/16 07:12:27]

nit: perhaps it would be better to have Blink create the parser thread via
Platform::createThread, and then pass that thread to
createThreadedResourceProvider? That is more consistent with the notion that
this is viewed as "the parser thread".

+        ASSERT(s_parserThread && s_parserThread == resourceProvider->resourceProviderThread());
+    }
+
+    if (!s_parserThread) {
+        // If we don't have a thread object, we can't use threading and must
+        // fall back to singlethreaded mode by having our own tokenizer.
+        if (!m_token)
+            m_token = adoptPtr(new HTMLToken);
+        if (!m_tokenizer)
+            m_tokenizer = HTMLTokenizer::create(m_options);
+        return;
+    }
+
     m_haveBackgroundParser = true;
 
     RefPtr<WeakReference<BackgroundHTMLParser> > reference = WeakReference<BackgroundHTMLParser>::createUnbound();
     m_backgroundParser = WeakPtr<BackgroundHTMLParser>(reference);
 
     OwnPtr<BackgroundHTMLParser::Configuration> config = adoptPtr(new BackgroundHTMLParser::Configuration);
     config->options = m_options;
     config->parser = m_weakFactory.createWeakPtr();
     config->xssAuditor = adoptPtr(new XSSAuditor);
     config->xssAuditor->init(document(), &m_xssAuditorDelegate);
     config->preloadScanner = adoptPtr(new TokenPreloadScanner(document()->url().copy(), document()->devicePixelRatio()));
     config->decoder = takeDecoder();
+    config->resourceProvider = resourceProvider.release();
 
     ASSERT(config->xssAuditor->isSafeToSendToAnotherThread());
     ASSERT(config->preloadScanner->isSafeToSendToAnotherThread());
-    HTMLParserThread::shared()->postTask(bind(&BackgroundHTMLParser::start, reference.release(), config.release()));
+    s_parserThread->postTask(new Task(bind(&BackgroundHTMLParser::start, reference.release(), config.release())));
 }
 
 void HTMLDocumentParser::stopBackgroundParser()
 {
     ASSERT(shouldUseThreading());
     ASSERT(m_haveBackgroundParser);
+    ASSERT(s_parserThread);
     m_haveBackgroundParser = false;
 
-    HTMLParserThread::shared()->postTask(bind(&BackgroundHTMLParser::stop, m_backgroundParser));
+    s_parserThread->postTask(new Task(bind(&BackgroundHTMLParser::stop, m_backgroundParser)));
     m_weakFactory.revokeAll();
 }
 
 void HTMLDocumentParser::append(PassRefPtr<StringImpl> 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());
+    ASSERT(!m_haveBackgroundParser);
 
     // pumpTokenizer can cause this parser to be detached from the Document,
     // but we need to ensure it isn't deleted yet.
     RefPtr<HTMLDocumentParser> protect(this);
     TRACE_EVENT1("net", "HTMLDocumentParser::append", "size", inputSource->length());
     String source(inputSource);
 
     if (m_preloadScanner) {
         if (m_input.current().isEmpty() && !isWaitingForScripts()) {
             // We have parsed until the end of the current input and so are now moving ahead of the preload scanner.
@@ skipping 81 matching lines @@
     // FIXME: We should ASSERT(!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.
 
     // 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();
-        HTMLParserThread::shared()->postTask(bind(&BackgroundHTMLParser::finish, m_backgroundParser));
+        s_parserThread->postTask(new Task(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 = adoptPtr(new HTMLToken);
         m_tokenizer = HTMLTokenizer::create(m_options);
@@ skipping 148 matching lines @@
 {
     if (m_parserScheduler)
         m_parserScheduler->resume();
 }
 
 void HTMLDocumentParser::appendBytes(const char* data, size_t length)
 {
     if (!length || isStopped())
         return;
 
-    if (shouldUseThreading()) {
-        if (!m_haveBackgroundParser)
-            startBackgroundParser();
+    if (shouldUseThreading() && !m_haveBackgroundParser)
+        startBackgroundParser();
+
+    if (m_haveBackgroundParser) {
+        if (m_parserThreadIsStandalone)
+            return; // If this is set, the parser thread will receive the data directly.
 
         OwnPtr<Vector<char> > buffer = adoptPtr(new Vector<char>(length));
         memcpy(buffer->data(), data, length);
         TRACE_EVENT1("net", "HTMLDocumentParser::appendBytes", "size", (unsigned)length);
 
-        HTMLParserThread::shared()->postTask(bind(&BackgroundHTMLParser::appendBytes, m_backgroundParser, buffer.release()));
+        ASSERT(s_parserThread);
+        s_parserThread->postTask(new Task(bind(&BackgroundHTMLParser::appendBytes, m_backgroundParser, buffer.release())));
         return;
     }
 
     DecodedDataDocumentParser::appendBytes(data, length);
 }
 
+void HTMLDocumentParser::didSwitchedToBackgroundClient()
+{
+    if (isDetached())
+        return;
+
+    ASSERT(s_parserThread);
+    ASSERT(m_haveBackgroundParser);
+    // At this point the background parser will start receiving data chunks directly
+    // from the I/O thread and we no longer need to pass it any data.
+    m_parserThreadIsStandalone = true;
+    s_parserThread->postTask(new Task(bind(&BackgroundHTMLParser::didSwitchedToBackgroundClient, m_backgroundParser)));
+}
+
 void HTMLDocumentParser::flush()
 {
     // If we've got no decoder, we never received any data.
     if (isDetached() || needsDecoder())
         return;
 
     if (m_haveBackgroundParser)
-        HTMLParserThread::shared()->postTask(bind(&BackgroundHTMLParser::flush, m_backgroundParser));
+        s_parserThread->postTask(new Task(bind(&BackgroundHTMLParser::flush, m_backgroundParser)));
     else
         DecodedDataDocumentParser::flush();
 }
 
 void HTMLDocumentParser::setDecoder(PassOwnPtr<TextResourceDecoder> decoder)
 {
     ASSERT(decoder);
     DecodedDataDocumentParser::setDecoder(decoder);
 
     if (m_haveBackgroundParser)
-        HTMLParserThread::shared()->postTask(bind(&BackgroundHTMLParser::setDecoder, m_backgroundParser, takeDecoder()));
+        s_parserThread->postTask(new Task(bind(&BackgroundHTMLParser::setDecoder, m_backgroundParser, takeDecoder())));
 }
 
 }