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 19 matching lines @@
 #include "core/dom/Document.h"
 #include "core/dom/DocumentParserTiming.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)
     : 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_willExecuteWhenDocumentFinishedParsing(false)
     , m_forceAsync(!parserInserted)
     , m_createdDuringDocumentWrite(createdDuringDocumentWrite)
     , m_asyncExecType(ScriptRunner::None)
+    , m_documentWriteIntervention(DocumentWriteIntervention::DocumentWriteInterventionNone)
 {
     DCHECK(m_element);
     if (parserInserted && element->document().scriptableDocumentParser() && !element->document().isInDocumentWrite())
         m_startLineNumber = element->document().scriptableDocumentParser()->lineNumber();
 }
 
 ScriptLoader::~ScriptLoader()
 {
 }
 
 DEFINE_TRACE(ScriptLoader)
 {
     visitor->trace(m_element);
     visitor->trace(m_resource);
     visitor->trace(m_pendingScript);
     ScriptResourceClient::trace(visitor);
 }
 
+void ScriptLoader::setFetchDocWrittenScriptDeferIdle()
+{
+    DCHECK(!m_createdDuringDocumentWrite);
+    m_documentWriteIntervention = DocumentWriteIntervention::FetchDocWrittenScriptDeferIdle;
+}
+
 void ScriptLoader::didNotifySubtreeInsertionsToDocument()
 {
     if (!m_parserInserted)
         prepareScript(); // FIXME: Provide a real starting line number here.
 }
 
 void ScriptLoader::childrenChanged()
 {
     if (!m_parserInserted && m_element->isConnected())
         prepareScript(); // FIXME: Provide a real starting line number here.
@@ skipping 129 matching lines @@
 
     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())
             defer = FetchRequest::LazyLoad;
+        if (m_documentWriteIntervention == DocumentWriteIntervention::FetchDocWrittenScriptDeferIdle)
+            defer = FetchRequest::IdleLoad;
         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::FetchDocWrittenScriptDeferIdle) {
+        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 55 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::FetchDocWrittenScriptDeferIdle) {
+            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::DoNotFetchDocWrittenScript;
+    }
+
+    return true;
 }
 
 bool isHTMLScriptLoader(Element* element)
 {
     DCHECK(element);
     return isHTMLScriptElement(*element);
 }
 
 bool isSVGScriptLoader(Element* element)
 {
@@ skipping 135 matching lines @@
             dispatchLoadEvent();
         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::FetchDocWrittenScriptDeferIdle) {
+        memoryCache()->remove(resource);
+        m_pendingScript->stopWatchingForLoad();
+        return;
+    }
+
     DCHECK(m_asyncExecType != ScriptRunner::None);
 
     Document* contextDocument = m_element->document().contextDocument();
     if (!contextDocument) {
         detach();
         return;
     }
 
     ASSERT_UNUSED(resource, resource == m_resource);
 
@@ skipping 48 matching lines @@
     if (isHTMLScriptLoader(element))
         return toHTMLScriptElement(element)->loader();
 
     if (isSVGScriptLoader(element))
         return toSVGScriptElement(element)->loader();
 
     return 0;
 }
 
 } // namespace blink