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

third_party/WebKit/Source/core/dom/ScriptLoader.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 18 matching lines @@
 #include "core/SVGNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/IgnoreDestructiveWriteCountIncrementer.h"
 #include "core/dom/ScriptLoaderClient.h"
 #include "core/dom/ScriptRunner.h"
 #include "core/dom/ScriptableDocumentParser.h"
 #include "core/dom/Text.h"
 #include "core/events/Event.h"
 #include "core/fetch/AccessControlStatus.h"
 #include "core/fetch/FetchRequest.h"
+#include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/SubresourceIntegrity.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/CrossOriginAttribute.h"
 #include "core/html/HTMLScriptElement.h"
 #include "core/html/imports/HTMLImport.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/svg/SVGScriptElement.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
+#include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebFrameScheduler.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringHash.h"
 
 namespace blink {
 
-ScriptLoader::ScriptLoader(Element* element, bool parserInserted, bool alreadyStarted, bool createdDuringDocumentWrite)
+ScriptLoader::ScriptLoader(Element* element, bool parserInserted, bool alreadyStarted, bool createdDuringDocumentWrite, bool blockedDocWriteScriptAsyncFetch)
     : m_element(element)
     , m_startLineNumber(WTF::OrdinalNumber::beforeFirst())
     , m_parserInserted(parserInserted)
     , m_isExternalScript(false)
     , m_alreadyStarted(alreadyStarted)
     , m_haveFiredLoad(false)
     , m_willBeParserExecuted(false)
     , m_readyToBeParserExecuted(false)
     , m_willExecuteInOrder(false)
     , m_willExecuteWhenDocumentFinishedParsing(false)
     , m_forceAsync(!parserInserted)
     , m_createdDuringDocumentWrite(createdDuringDocumentWrite)
+    , m_documentWriteIntervention(DocumentWriteIntervention::DocumentWriteInterventionNone)
 {
     DCHECK(m_element);
     if (parserInserted && element->document().scriptableDocumentParser() && !element->document().isInDocumentWrite())
         m_startLineNumber = element->document().scriptableDocumentParser()->lineNumber();
+    if (blockedDocWriteScriptAsyncFetch) {
+        DCHECK(!m_createdDuringDocumentWrite);
+        m_documentWriteIntervention = DocumentWriteIntervention::AsyncLowPriorityFetchForBlockedScript;
+    }
 }
 
 ScriptLoader::~ScriptLoader()
 {
 }
 
 DEFINE_TRACE(ScriptLoader)
 {
     visitor->trace(m_element);
     visitor->trace(m_resource);
@@ skipping 144 matching lines @@
     if (!isScriptForEventSupported())
         return false;
 
     if (!client->charsetAttributeValue().isEmpty())
         m_characterEncoding = client->charsetAttributeValue();
     else
         m_characterEncoding = elementDocument.characterSet();
 
     if (client->hasSourceAttribute()) {
         FetchRequest::DeferOption defer = FetchRequest::NoDefer;
-        if (!m_parserInserted || client->asyncAttributeValue() || client->deferAttributeValue())
+        if (!m_parserInserted || client->asyncAttributeValue() || client->deferAttributeValue()
+            || m_documentWriteIntervention == DocumentWriteIntervention::AsyncLowPriorityFetchForBlockedScript)
             defer = FetchRequest::LazyLoad;
         if (!fetchScript(client->sourceAttributeValue(), defer))
             return false;
     }
 
+    // Since the asynchronous, low priority fetch for doc.written blocked
+    // script is not for execution, return early from here. Watch for its
+    // completion to be able to remove it from the memory cache.
+    if (m_documentWriteIntervention == DocumentWriteIntervention::AsyncLowPriorityFetchForBlockedScript) {
+        m_pendingScript = PendingScript::create(m_element, m_resource.get());
+        m_pendingScript->watchForLoad(this);
+        return true;
+    }
+
     if (client->hasSourceAttribute() && client->deferAttributeValue() && m_parserInserted && !client->asyncAttributeValue()) {
         m_willExecuteWhenDocumentFinishedParsing = true;
         m_willBeParserExecuted = true;
     } else if (client->hasSourceAttribute() && m_parserInserted && !client->asyncAttributeValue()) {
         m_willBeParserExecuted = true;
     } else if (!client->hasSourceAttribute() && m_parserInserted && !elementDocument.isScriptExecutionReady()) {
         m_willBeParserExecuted = true;
         m_readyToBeParserExecuted = true;
     } else if (client->hasSourceAttribute() && !client->asyncAttributeValue() && !m_forceAsync) {
         m_pendingScript = PendingScript::create(m_element, m_resource.get());
@@ skipping 53 matching lines @@
         }
         request.setDefer(defer);
 
         String integrityAttr = m_element->fastGetAttribute(HTMLNames::integrityAttr);
         if (!integrityAttr.isEmpty()) {
             IntegrityMetadataSet metadataSet;
             SubresourceIntegrity::parseIntegrityAttribute(integrityAttr, metadataSet, elementDocument);
             request.setIntegrityMetadata(metadataSet);
         }
 
+        if (m_documentWriteIntervention == DocumentWriteIntervention::AsyncLowPriorityFetchForBlockedScript) {
+            // Set interventions info in resourceRequest so that priority can
+            // be set accordingly.
+            request.mutableResourceRequest().setInterventionsInfo(InterventionsFlag::InterventionBlockedDocWriteScriptAsyncFetch);
+            request.mutableResourceRequest().setHTTPHeaderField("Intervention", "<https://www.chromestatus.com/feature/5718547946799104>");
+        }
+
         m_resource = ScriptResource::fetch(request, elementDocument->fetcher());
 
         m_isExternalScript = true;
     }
 
-    if (m_resource)
-        return true;
+    if (!m_resource) {
+        dispatchErrorEvent();
+        return false;
+    }
 
-    dispatchErrorEvent();
-    return false;
+    if (m_createdDuringDocumentWrite && m_resource->resourceRequest().getCachePolicy() == WebCachePolicy::ReturnCacheDataDontLoad) {
+        m_documentWriteIntervention = DocumentWriteIntervention::DisallowedFetchForDocWrittenScript;
+    }
+
+    return true;
 }
 
 bool isHTMLScriptLoader(Element* element)
 {
     DCHECK(element);
     return isHTMLScriptElement(*element);
 }
 
 bool isSVGScriptLoader(Element* element)
 {
@@ skipping 112 matching lines @@
         else
             dispatchErrorEvent();
     }
     m_resource = nullptr;
 }
 
 void ScriptLoader::notifyFinished(Resource* resource)
 {
     DCHECK(!m_willBeParserExecuted);
 
+    // We do not need this script in the memory cache. The primary goals of
+    // sending this fetch request are to let the third party server know
+    // about the document.write scripts intervention and populate the http
+    // cache for subsequent uses.
+    if (m_documentWriteIntervention == DocumentWriteIntervention::AsyncLowPriorityFetchForBlockedScript) {
+        memoryCache()->remove(resource);
+        m_pendingScript->stopWatchingForLoad();
+        return;
+    }
+
     Document* contextDocument = m_element->document().contextDocument();
     if (!contextDocument) {
         detach();
         return;
     }
 
     ASSERT_UNUSED(resource, resource == m_resource);
 
     ScriptRunner::ExecutionType runOrder = m_willExecuteInOrder ? ScriptRunner::IN_ORDER_EXECUTION : ScriptRunner::ASYNC_EXECUTION;
     if (m_resource->errorOccurred()) {
@@ skipping 47 matching lines @@
     if (isHTMLScriptLoader(element))
         return toHTMLScriptElement(element)->loader();
 
     if (isSVGScriptLoader(element))
         return toSVGScriptElement(element)->loader();
 
     return 0;
 }
 
 } // namespace blink