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

third_party/WebKit/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 16 matching lines @@
 
 #include "bindings/core/v8/Microtask.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
 #include "core/dom/DocumentParserTiming.h"
 #include "core/dom/Element.h"
 #include "core/dom/IgnoreDestructiveWriteCountIncrementer.h"
 #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"
 #include "core/html/parser/HTMLScriptRunnerHost.h"
 #include "core/html/parser/NestingLevelIncrementer.h"
 #include "platform/Histogram.h"
 #include "platform/TraceEvent.h"
 #include "platform/TracedValue.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebFrameScheduler.h"
@@ skipping 195 matching lines @@
     }
     for (auto& script : m_scriptsToExecuteAfterParsing) {
         if (script->resource() == resource) {
             script->stopWatchingForLoad();
             script->releaseElementAndClear();
             return;
         }
     }
 }
 
+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
     // notifying the host (i.e., parser) if these were initiated by nested
     // document.write()s. The cancellation may have been triggered by
     // script execution to signal an abrupt stop (e.g., window.close().)
     //
     // The parser is unprepared to be told, and doesn't need to be.
     if (isExecutingScript() && cachedResource->wasCanceled()) {
         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"'
 // http://whatwg.org/html#scriptEndTag
 // Script handling lives outside the tree builder to keep each class simple.
 void HTMLScriptRunner::execute(Element* scriptElement, const TextPosition& scriptStartPosition)
 {
     ASSERT(scriptElement);
     TRACE_EVENT1("blink", "HTMLScriptRunner::execute",
         "data", getTraceArgsForScriptElement(scriptElement, scriptStartPosition));
@@ skipping 175 matching lines @@
 DEFINE_TRACE(HTMLScriptRunner)
 {
     visitor->trace(m_document);
     visitor->trace(m_host);
     visitor->trace(m_parserBlockingScript);
     visitor->trace(m_scriptsToExecuteAfterParsing);
     ScriptResourceClient::trace(visitor);
 }
 
 } // namespace blink