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);
+    DCHECK(scriptLoader);
+    scriptLoader->setFetchDocWrittenScriptDeferIdle();
+    scriptLoader->prepareScript(scriptStartPosition);
+}
+
+bool HTMLScriptRunner::possiblyFetchBlockedDocWriteScript(Resource* cachedResource)

[Nate Chapin, 2016/09/06 20:28:12]

Nit: |cachedResource| is anachronistic. Just |resource| is preferable.

[shivanisha, 2016/09/15 20:35:08]

done.

+{
+    // 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 shouldFetchBlockedDocWriteScript = 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()) {
+            shouldFetchBlockedDocWriteScript = true;

[haraken, 2016/09/07 01:47:36]

It's confusing to set "shouldFetch"BlockedDocWriteScript true when
"disallowedFetch"ForDocWrittenScript returns true...

Does "DoNotFetchDocWrittenScript" mean that we should not fetch the script
during loading but should fetch the script after the loading has finished? Then
how is it different from "FetchDocWrittenScriptDeferIdle"?

[shivanisha, 2016/09/15 20:35:08]

disallowedFetch"ForDocWrittenScript was set when this resource was requested and
this code is executed on receiving the response/error for the resource.
shouldFetchBlockedDocWriteScript implies if another fetch should be done for
this resource.

DoNotFetchDocWrittenScript simply means that this request should not be fetched
from the network.(set for 1st fetch request)
FetchDocWrittenScriptDeferIdle means that a script that was blocked should be
fetched again using idle priority. (set for 2nd fetch request)

+            startingPosition = m_parserBlockingScript->startingPosition();
+            isParserInserted = scriptLoader->isParserInserted();
+        }
+    }
+
+    if (!shouldFetchBlockedDocWriteScript)
+        return false;
+
+    m_host->notifyScriptLoaded(cachedResource);
+
+    // 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);
+    return true;
+}
+
 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.
+    if (possiblyFetchBlockedDocWriteScript(cachedResource))
+        return;
+
     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(Element* scriptElement, const TextPosition& scriptStartPosition)
 {
     ASSERT(scriptElement);
     TRACE_EVENT1("blink", "HTMLScriptRunner::execute",
@@ skipping 176 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