Add about:flags support for doc.write script blocking.

third_party/WebKit/Source/core/loader/FrameFetchContext.cpp

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 57 matching lines @@
 #include "platform/network/ResourceTimingInfo.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebFrameScheduler.h"
 
 #include <algorithm>
 
 namespace blink {
 
+namespace {
+
+    bool ShouldDisallowFetchForMainFrameScript(const ResourceRequest& request, FetchRequest::DeferOption defer, Document& document)

[kinuko, 2016/04/11 13:02:27]

Drive-by nit: please not indent in namespace

[Bryan McQuade, 2016/04/11 13:15:24]

for some reason git cl format likes to add the spaces. removed.

[jkarlin, 2016/04/11 14:52:27]

const Document& ? 

It looks like isInDocumentWrite needs to be made const.

[Bryan McQuade, 2016/04/11 16:28:29]

Done

+    {
+        // Only scripts inserted via document.write are candidates for having their
+        // fetch disallowed.
+        if (!document.isInDocumentWrite()) {
+            return false;
+        }
+
+        if (!document.settings()) {
+            return false;
+        }
+
+        // Only blocking in slow connections where the performance penalty is worst
+        // case.  For now we restrict slow connections to 2G, in future this might
+        // be expanded using the network quality estimator.

[jkarlin, 2016/04/11 14:52:27]

Not a sentence, perhaps s/Only Blocking in/Block in/

I'd remove the NQE speculation from the comment.

[Bryan McQuade, 2016/04/11 16:28:30]

Good call. Once I removed this part of the comment, I decided it was appropriate
to remove the entire comment, since it doesn't convey anything beyond what's
captured in the code below. Japhet encouraged me to try to remove obvious
comments in a prior review. Let me know if you think the comment should be
restored.

+        const bool isSlowConnection = networkStateNotifier().connectionType() == WebConnectionTypeCellular2G;
+        const bool disallowFetch = document.settings()->disallowFetchForDocWrittenScriptsInMainFrame() || (document.settings()->disallowFetchForDocWrittenScriptsInMainFrameOnSlowConnections() && isSlowConnection);
+        if (!disallowFetch) {
+            return false;
+        }
+
+        // only synchronously loaded scripts should be blocked

[kinuko, 2016/04/11 13:02:27]

nit: only -> Only, and end comment with period

[Bryan McQuade, 2016/04/11 13:15:24]

Done.

+        if (defer != FetchRequest::NoDefer) {
+            return false;
+        }
+
+        // Not blocking same origin scripts as they may be used to render main page

[jkarlin, 2016/04/11 14:52:27]

Not a sentence, perhaps s/Not blocking/Don't block/

[Bryan McQuade, 2016/04/11 16:28:29]

Done

[Bryan McQuade, 2016/04/11 16:28:30]

Done

+        // content whereas cross-origin scripts inserted via document.write are
+        // likely to be third party content.
+        if (request.url().host() == document.getSecurityOrigin()->domain()) {
+            return false;
+        }
+
+        return true;
+    }
+
+} // namespace
+
 FrameFetchContext::FrameFetchContext(DocumentLoader* loader, Document* document)
     : m_document(document)
     , m_documentLoader(loader)
     , m_imageFetched(false)
 {
     ASSERT(frame());
 }
 
 FrameFetchContext::~FrameFetchContext()
 {
@@ skipping 110 matching lines @@
                 return WebCachePolicy::BypassingCache;
             if (frameLoadType == FrameLoadTypeReload)
                 return WebCachePolicy::ValidatingCacheData;
         }
         return WebCachePolicy::UseProtocolCachePolicy;
     }
 
     // For users on slow connections, we want to avoid blocking the parser in
     // the main frame on script loads inserted via document.write, since it can
     // add significant delays before page content is displayed on the screen.
-    if (type == Resource::Script && isMainFrame()) {
-        const bool isInDocumentWrite = m_document && m_document->isInDocumentWrite();
-        const bool disallowFetchForDocWriteScripts = frame()->settings() && frame()->settings()->disallowFetchForDocWrittenScriptsInMainFrame();
-
-        if (isInDocumentWrite && disallowFetchForDocWriteScripts) {
-            // only synchronously loaded scripts should be blocked
-            const bool isSync = defer == FetchRequest::NoDefer;
-
-            // Not blocking same origin scripts as they may be used to render main page content
-            // whereas cross-origin scripts inserted via document.write are likely
-            // for third party content.
-            const bool isThirdParty = request.url().host() != m_document->getSecurityOrigin()->domain();
-
-            // Only blocking in slow connections where the performance penalty is worst case.
-            // For now we restrict slow connections to 2G, in future this might be expanded using the
-            // network quality estimator.
-            const bool isSlowConnection = networkStateNotifier().connectionType() == WebConnectionTypeCellular2G;
-
-            if (isSync && isThirdParty && isSlowConnection)
-                return WebCachePolicy::ReturnCacheDataDontLoad;
-        }
+    if (type == Resource::Script && isMainFrame() && m_document && ShouldDisallowFetchForMainFrameScript(request, defer, *m_document)) {
+        return WebCachePolicy::ReturnCacheDataDontLoad;
     }
 
     if (request.isConditional())
         return WebCachePolicy::ValidatingCacheData;
 
     if (m_documentLoader && m_document && !m_document->loadEventFinished()) {
         // For POST requests, we mutate the main resource's cache policy to avoid form resubmission.
         // This policy should not be inherited by subresources.
         WebCachePolicy mainResourceCachePolicy = m_documentLoader->request().getCachePolicy();
         if (m_documentLoader->request().httpMethod() == "POST") {
@@ skipping 542 matching lines @@
 }
 
 DEFINE_TRACE(FrameFetchContext)
 {
     visitor->trace(m_document);
     visitor->trace(m_documentLoader);
     FetchContext::trace(visitor);
 }
 
 } // namespace blink