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

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

 /*
  * 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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 70 matching lines @@
     void handleAsyncAttribute();
 
     virtual bool isReady() const { return m_pendingScript && m_pendingScript->isReady(); }
     bool errorOccurred() const { return m_pendingScript && m_pendingScript->errorOccurred(); }
 
     // Clears the connection to the PendingScript (and Element and Resource).
     void detach();
 
     bool wasCreatedDuringDocumentWrite() { return m_createdDuringDocumentWrite; }
 
+    bool disallowedFetchForDocWrittenScript() { return m_documentWriteIntervention == DocumentWriteIntervention::DisallowedFetchForDocWrittenScript; }

[haraken, 2016/08/23 00:30:39]

disallowedFetchForDocWrittenScript => shouldFetchDocWrittenScript ?

[shivanisha, 2016/08/24 17:47:40]

Named it as disallowedFetchForDocWrittenScript so that it is consistent with the
function shouldDisallowFetchForMainFrameScript() which is the decision making
function. This one just returns true or false based on what decision
shouldDisallowFetchForMainFrameScript() took.

+    void setBlockedDocWriteScriptAsyncFetch();

[haraken, 2016/08/23 00:30:39]

"BlockedDocWrite" sounds a bit strange to me. Is there any non-blocking
document.write?

[shivanisha, 2016/08/24 17:47:40]

Here blocking is used not in the sense of parser-blocking but whether the
intervention actually blocked the fetch of this script. There are conditions
like a reload, cache-hit where the intervention does not block the script.

+
 protected:
     ScriptLoader(Element*, bool createdByParser, bool isEvaluated, bool createdDuringDocumentWrite);
 
 private:
     bool ignoresLoadRequest() const;
     bool isScriptForEventSupported() const;
     void logScriptMimetype(ScriptResource*, LocalFrame*, String);
 
     bool fetchScript(const String& sourceUrl, FetchRequest::DeferOption);
 
@@ skipping 13 matching lines @@
     bool m_isExternalScript : 1;
     bool m_alreadyStarted : 1;
     bool m_haveFiredLoad : 1;
     bool m_willBeParserExecuted : 1; // Same as "The parser will handle executing the script."
     bool m_readyToBeParserExecuted : 1;
     bool m_willExecuteInOrder : 1;
     bool m_willExecuteWhenDocumentFinishedParsing : 1;
     bool m_forceAsync : 1;
     const bool m_createdDuringDocumentWrite : 1;
 
+    enum DocumentWriteIntervention {
+        DocumentWriteInterventionNone = 0,
+        // Based on what shouldDisallowFetchForMainFrameScript() returns.
+        // This script will be blocked if not present in http cache.
+        DisallowedFetchForDocWrittenScript,

[haraken, 2016/08/23 00:30:39]

DoNotFetchDocWrittenScript ?

[shivanisha, 2016/08/24 17:47:40]

Named such so that it is consistent with shouldDisallowFetchForMainFrameScript()

+        // Is it a fetch (non parser-blocking, lowest priority) for the blocked script.
+        AsyncLowPriorityFetchForBlockedScript,

[haraken, 2016/08/23 00:30:39]

FetchDocWrittenScriptAsynchrously ?

[shivanisha, 2016/08/24 17:47:40]

Wanted to say that it is a fetch for a script whose original fetch was blocked
by the intervention, thus "block" is part of the name.

+    };
+
+    DocumentWriteIntervention m_documentWriteIntervention;
+
     Member<PendingScript> m_pendingScript;
 };
 
 ScriptLoader* toScriptLoaderIfPossible(Element*);
 
 } // namespace blink
 
 #endif // ScriptLoader_h