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 89 matching lines @@
 inline PassRefPtrWillBeRawPtr<Event> createScriptLoadEvent()
 {
     return Event::create(EventTypeNames::load);
 }
 
 bool HTMLScriptRunner::isPendingScriptReady(const PendingScript& script)
 {
     m_hasScriptsWaitingForResources = !m_document->isScriptExecutionReady();
     if (m_hasScriptsWaitingForResources)
         return false;
     if (script.resource() && !script.resource()->isLoaded())

[haraken, 2014/09/10 05:57:52]

Not related to this CL, is it possible that script.resource() is 0 here?

If script.resource() is 0, isPendingScriptReady returns true, which sounds very
strange.

[marja, 2014/09/11 09:15:38]

Hmm, no idea.

         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 38 matching lines @@
     const double epsilon = 1;
     if (pendingScriptType == PendingScriptBlockingParser && !m_parserBlockingScriptAlreadyLoaded && compilationFinishTime > epsilon && loadFinishTime > epsilon) {
         blink::Platform::current()->histogramCustomCounts("WebCore.Scripts.ParsingBlocking.TimeBetweenLoadedAndCompiled", (compilationFinishTime - loadFinishTime) * 1000, 0, 10000, 50);
     }
 
     ASSERT(!isExecutingScript());
 }
 
 void HTMLScriptRunner::notifyFinished(Resource* cachedResource)
 {
+    // For a parser-blocking script, this function should be called only when
+    // the streaming is complete.
+    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 68 matching lines @@
     if (!requestPendingScript(m_parserBlockingScript, element))
         return;
 
     ASSERT(m_parserBlockingScript.resource());
 
     m_parserBlockingScriptAlreadyLoaded = m_parserBlockingScript.resource()->isLoaded();
     blink::Platform::current()->histogramEnumeration("WebCore.Scripts.ParsingBlocking.AlreadyLoaded", m_parserBlockingScriptAlreadyLoaded ? 1 : 0, 2);
     // 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_parserBlockingScriptAlreadyLoaded)
+    if (!m_parserBlockingScriptAlreadyLoaded) {
+        bool startedStreaming = ScriptStreamer::startStreaming(m_parserBlockingScript);
+        blink::Platform::current()->histogramEnumeration("WebCore.Scripts.ParsingBlocking.StartedStreaming", startedStreaming ? 1 : 0, 2);

[haraken, 2014/09/10 05:57:52]

You can add this in a separate CL.

[marja, 2014/09/11 09:15:38]

Hmm, which part? Calling startStreaming or the UMA? Why? I'll have a Finch
experiment for this, so even if I call startStreaming here, it'll only be
enabled for the finch population, not everybody. And the UMA is just one line,
so I don't see why I should create a separate CL for it.

         m_parserBlockingScript.watchForLoad(this);
+    }
 }
 
 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()) {
+            // FIXME: in addition to parser blocking scripts, stream also
+            // scripts which are not parser blocking.
             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);
 }
 
 }