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, const TextPosition& scriptStartPosition)
+{
+    ScriptLoader* scriptLoader = toScriptLoaderIfPossible(script);
+    // This contains both and ASSERTION and a null check since we should not
+    // be getting into the case of a null script element, but seem to be from
+    // time to time. The assertion is left in to help find those cases and
+    // is being tracked by <https://bugs.webkit.org/show_bug.cgi?id=60559>.
+    DCHECK(scriptLoader);
+    if (!scriptLoader)
+        return;
+    DCHECK(scriptLoader->isParserInserted());
+
+    scriptLoader = ScriptLoader::create(script, scriptLoader->isParserInserted(), false, false, true);
+    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()) {

[Charlie Harrison, 2016/08/19 21:24:27]

Will we ever hit this condition? Judging from the comment it seems like we
might?

[shivanisha, 2016/08/22 16:15:22]

Since its a canceled scenario, its fine to return from here and not send the
async GET request.

         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 = m_parserBlockingScript->element();
+    TextPosition startingPosition = m_parserBlockingScript->startingPosition();
+    ScriptLoader* scriptLoader = toScriptLoaderIfPossible(m_parserBlockingScript->element());
+    bool blockedDocWriteScriptAsyncFetch = false;
+
+    // Due to dependency violation, not able to check the exact error to be
+    // ERR_CACHE_MISS but other errors are rare with
+    // WebCachePolicy::ReturnCacheDataDontLoad.
+    if (cachedResource->errorOccurred() && m_parserBlockingScript->resource() == cachedResource
+        && scriptLoader->disallowedFetchForDocWrittenScript()) {
+        blockedDocWriteScriptAsyncFetch = true;
+    }
+
     m_host->notifyScriptLoaded(cachedResource);
+
+    if (blockedDocWriteScriptAsyncFetch) {
+        // remove this resource entry from memory cache as the new request
+        // should not join onto this existing entry.
+        memoryCache()->remove(cachedResource);
+        fetchBlockedDocWriteScript(element, 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