Sending an async GET request for doc.written blocked scripts.

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

Index: third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.cpp
diff --git a/third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.cpp b/third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.cpp
index 05c63f6a5e263a17e414899171190371b90a2073..18b71b26af8de775e449e4b6b08c1dcc817e8cd0 100644
--- a/third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.cpp
+++ b/third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.cpp
@@ -34,6 +34,7 @@
 #include "core/dom/ScriptLoader.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/Event.h"
+#include "core/fetch/MemoryCache.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/parser/HTMLInputStream.h"
@@ -249,6 +250,15 @@ void HTMLScriptRunner::stopWatchingResourceForLoad(Resource* resource)
     }
 }
 
+void fetchBlockedDocWriteScript(Element* script, bool isParserInserted, const TextPosition& scriptStartPosition)
+{
+    DCHECK(script);
+
+    ScriptLoader* scriptLoader = ScriptLoader::create(script, isParserInserted, false, false, true);
+    DCHECK(scriptLoader);
+    scriptLoader->prepareScript(scriptStartPosition);
+}
+
 void HTMLScriptRunner::notifyFinished(Resource* cachedResource)
 {
     // Handle cancellations of parser-blocking script loads without
@@ -261,7 +271,35 @@ void HTMLScriptRunner::notifyFinished(Resource* cachedResource)
         stopWatchingResourceForLoad(cachedResource);
         return;
     }
+
+    // If the script was blocked as part of document.write intervention,
+    // then send an asynchronous GET request with an interventions header.
+    Element* element = nullptr;
+    TextPosition startingPosition;
+    bool blockedDocWriteScriptAsyncFetch = false;
+    bool isParserInserted = false;
+    if (cachedResource->errorOccurred() && m_parserBlockingScript && m_parserBlockingScript->resource() == cachedResource) {
+        // Due to dependency violation, not able to check the exact error to be
+        // ERR_CACHE_MISS but other errors are rare with
+        // WebCachePolicy::ReturnCacheDataDontLoad.
+        element = m_parserBlockingScript->element();
+
+        ScriptLoader* scriptLoader = nullptr;
+        if (element && (scriptLoader = toScriptLoaderIfPossible(element)) && scriptLoader->disallowedFetchForDocWrittenScript()) {
+            blockedDocWriteScriptAsyncFetch = true;
+            startingPosition = m_parserBlockingScript->startingPosition();
+            isParserInserted = scriptLoader->isParserInserted();
+        }
+    }
+
     m_host->notifyScriptLoaded(cachedResource);
+
+    if (blockedDocWriteScriptAsyncFetch) {

[Nate Chapin, 2016/08/22 19:47:03]

Does this logic absolutely need to be after notifyScriptLoaded()? It adds a
bunch of complexity to have to spread it over.

[shivanisha, 2016/08/22 20:44:00]

I am not completely aware of the other threads that are going on simultaneously
but notifyScriptLoaded() does a bunch of things including
resumeParsingAfterScriptExecution() that calls 
HTMLDocumentParser::pumpTokenizer() and
HTMLDocumentParser::pumpPendingSpeculations(). If it does something that can
lead to posting tasks to other threads then it would be good to not delay its
execution. While debugging fetchBlockedDocWriteScript() using gdb I was seeing
it took a noticeable time before returning from ScriptResource::fetch() call.

Thoughts?

[Nate Chapin, 2016/08/22 20:55:12]

Hrm, ok. One option is to move all the new code here into a helper
(maybeFetchBlockedDocWriteScript() or something like that), have it return false
if it didn't fetch a blocked script, and let it have a
m_host->notifyScriptLoaded() call in the appropriate place in its own flow. If
it doesn't fetch anything, then it just falls through to the
notifyScriptLoaded() call here. That we at least contain this specialized logic.
WDYT?

[shivanisha, 2016/08/23 01:04:46]

Sounds good. done

+        // remove this resource entry from memory cache as the new request
+        // should not join onto this existing entry.
+        memoryCache()->remove(cachedResource);
+        fetchBlockedDocWriteScript(element, isParserInserted, startingPosition);
+    }
 }
 
 // Implements the steps for 'An end tag whose tag name is "script"'