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->setBlockedDocWriteScriptAsyncFetch();
+    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) {
+        // 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