Stream scripts to V8 as they load - Blink side.

Source/core/html/parser/HTMLScriptRunner.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 55 matching lines @@
 #endif
 }
 
 void HTMLScriptRunner::detach()
 {
     if (!m_document)
         return;
 
     if (m_parserBlockingScript.resource() && m_parserBlockingScript.watchingForLoad())
         stopWatchingForLoad(m_parserBlockingScript);
+    // If the script is streamed, watchingForLoad is false. In that case, we
+    // don't need to do anything (PendingScript will take care of cancelling the
+    // streaming).

[haraken, 2014/08/17 16:05:28]

It's a bit weird that the lifetime of not-streamed loading is taken care of by
the HTMLScriptRunner whereas the lifetime of streamed loading is taken care of
by PendingScripts. Can we refactor the code so that all loadings are taken care
of by PendingScripts?

(I guess you'll anyway need to make the change when you support
not-parser-blocking scripts.)

[haraken, 2014/08/17 16:05:28]

Move this comment to above line 74.

[marja, 2014/08/20 11:45:57]

I don't think it's accurate to say "lifetime of not-streamed loading is taken
care of by the HTMLScriptRunner whereas the lifetime of streamed loading is
taken care of by PendingScripts".

However, HTMLScriptRunner is *watching* non-streamed loads of parsing blocking
scripts, but not watching streamed loads, and not watching the load of
non-parsing-blocking scripts. (Thus functions like
HTMLScriptRunner::watchForLoad and stopWatchingForLoad.) So it's not about
managing the loading itself, but about watching it.

I can unify this though: ScriptStreamer can imitate a Resource so that the
HTMLScriptRunner doesn't know whether it's watching a Resource load or a
ScriptStreamer load. It'll just delegate the "watch" and "stopWatching" to
PendingScript, which will know what to do. I implemented that version and it
turned out pretty nice. Wdyt? I can also do this as a separate CL before the
actual streaming.

[haraken, 2014/08/20 15:00:19]

The new version looks nicer to me!

 
     while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
         PendingScript pendingScript = m_scriptsToExecuteAfterParsing.takeFirst();
         if (pendingScript.resource() && pendingScript.watchingForLoad())
             stopWatchingForLoad(pendingScript);
     }
     m_document = nullptr;
 }
 
 static KURL documentURLForScriptExecution(Document* document)
 {
     if (!document)
         return KURL();
 
     if (!document->frame()) {
         if (document->importsController())
             return document->url();
         return KURL();
     }
 
     // Use the URL of the currently active document for this frame.
     return document->frame()->document()->url();
 }
 
 inline PassRefPtrWillBeRawPtr<Event> createScriptLoadEvent()
 {
     return Event::create(EventTypeNames::load);
 }
 
-ScriptSourceCode HTMLScriptRunner::sourceFromPendingScript(const PendingScript& script, bool& errorOccurred) const
+ScriptSourceCode HTMLScriptRunner::sourceFromPendingScript(PendingScript& script, bool& errorOccurred) const
 {
     if (script.resource()) {
         errorOccurred = script.resource()->errorOccurred();
         ASSERT(script.resource()->isLoaded());
+        if (script.streamer()) {
+            return ScriptSourceCode(script.releaseStreamer(), script.resource());
+        }
         return ScriptSourceCode(script.resource());
     }
+    ASSERT(!script.isStreaming());

[haraken, 2014/08/17 16:05:28]

Help me understand: Why is it guaranteed that script.isStreaming() is false at
this point?

[marja, 2014/08/20 11:45:57]

Because this function is only called when we want to compile the script, so,
streaming must have finished before that. (This can only be called after
HTMLScriptRunner has gotten the "finished" notification.)

(We cannot extract the source code from a resource which is still loading.)

     errorOccurred = false;
     return ScriptSourceCode(script.element()->textContent(), documentURLForScriptExecution(m_document), script.startingPosition());
 }
 
 bool HTMLScriptRunner::isPendingScriptReady(const PendingScript& script)
 {
     m_hasScriptsWaitingForResources = !m_document->isScriptExecutionReady();
     if (m_hasScriptsWaitingForResources)
         return false;
     if (script.resource() && !script.resource()->isLoaded())
         return false;
+    if (script.isStreaming())
+        return false;
     return true;
 }
 
 void HTMLScriptRunner::executeParsingBlockingScript()
 {
     ASSERT(m_document);
     ASSERT(!isExecutingScript());
     ASSERT(m_document->isScriptExecutionReady());
     ASSERT(isPendingScriptReady(m_parserBlockingScript));
 
@@ skipping 49 matching lines @@
 
 void HTMLScriptRunner::stopWatchingForLoad(PendingScript& pendingScript)
 {
     ASSERT(pendingScript.watchingForLoad());
     pendingScript.resource()->removeClient(this);
     pendingScript.setWatchingForLoad(false);
 }
 
 void HTMLScriptRunner::notifyFinished(Resource* cachedResource)
 {
+    // This function should not be called for the parser blocking script, if
+    // we've finished loading but we're still streaming it. It will be called
+    // when the streaming has completed too.

[haraken, 2014/08/17 16:05:28]

This comment is a bit misleading. Slightly better:

// For a parser-blocking script, this function should be called only when the
streaming is complete.

[marja, 2014/08/20 11:45:57]

Done.

+    ASSERT(!(m_parserBlockingScript.resource() == cachedResource
+        && m_parserBlockingScript.isStreaming()));
     m_host->notifyScriptLoaded(cachedResource);
 }
 
 // Implements the steps for 'An end tag whose tag name is "script"'
 // http://whatwg.org/html#scriptEndTag
 // Script handling lives outside the tree builder to keep each class simple.
 void HTMLScriptRunner::execute(PassRefPtrWillBeRawPtr<Element> scriptElement, const TextPosition& scriptStartPosition)
 {
     ASSERT(scriptElement);
     // FIXME: If scripting is disabled, always just return.
@@ skipping 66 matching lines @@
 void HTMLScriptRunner::requestParsingBlockingScript(Element* element)
 {
     if (!requestPendingScript(m_parserBlockingScript, element))
         return;
 
     ASSERT(m_parserBlockingScript.resource());
 
     // We only care about a load callback if resource is not already
     // in the cache. Callers will attempt to run the m_parserBlockingScript
     // if possible before returning control to the parser.
-    if (!m_parserBlockingScript.resource()->isLoaded())
-        watchForLoad(m_parserBlockingScript);
+    if (!m_parserBlockingScript.resource()->isLoaded()) {
+        if (!V8ScriptStreamer::startStreaming(&m_parserBlockingScript, this)) {
+            watchForLoad(m_parserBlockingScript);
+        }
+    }
 }
 
 void HTMLScriptRunner::requestDeferredScript(Element* element)
 {
     PendingScript pendingScript;
     if (!requestPendingScript(pendingScript, element))
         return;
 
     ASSERT(pendingScript.resource());
     m_scriptsToExecuteAfterParsing.append(pendingScript);
@@ skipping 37 matching lines @@
 
         InsertionPointRecord insertionPointRecord(m_host->inputStream());
         NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
 
         scriptLoader->prepareScript(scriptStartPosition);
 
         if (!scriptLoader->willBeParserExecuted())
             return;
 
         if (scriptLoader->willExecuteWhenDocumentFinishedParsing()) {
+            // TODO(marja): in addition to parser blocking scripts, stream also

[haraken, 2014/08/17 16:05:28]

Nit: TODO(marja) => FIXME

[marja, 2014/08/20 11:45:57]

Done.

+            // scripts which are not parser blocking.

[haraken, 2014/08/17 16:05:28]

I wonder if there is any particular reason you cannot enable the streaming for
not-parser-blocking scripts. I'm fine with leaving this as a FIXME for a
separate CL, but I'm curious if there is any particular reason you cannot do it
easily.

[marja, 2014/08/20 11:45:57]

(See the other comment.)

             requestDeferredScript(script);
         } else if (scriptLoader->readyToBeParserExecuted()) {
             if (m_scriptNestingLevel == 1) {
                 m_parserBlockingScript.setElement(script);
                 m_parserBlockingScript.setStartingPosition(scriptStartPosition);
             } else {
                 ScriptSourceCode sourceCode(script->textContent(), documentURLForScriptExecution(m_document), scriptStartPosition);
                 scriptLoader->executeScript(sourceCode);
             }
         } else {
             requestParsingBlockingScript(script);
         }
     }
 }
 
 void HTMLScriptRunner::trace(Visitor* visitor)
 {
     visitor->trace(m_document);
     visitor->trace(m_host);
     visitor->trace(m_parserBlockingScript);
     visitor->trace(m_scriptsToExecuteAfterParsing);
 }
 
 }