doc.write blocking intervention warning header

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 89 matching lines @@
     case WebEffectiveConnectionType::Type3G:
     case WebEffectiveConnectionType::Type4G:
     case WebEffectiveConnectionType::TypeUnknown:
     case WebEffectiveConnectionType::TypeOffline:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
-bool shouldDisallowFetchForMainFrameScript(const ResourceRequest& request,
-                                           FetchRequest::DeferOption defer,
-                                           Document& document) {
+bool shouldDisallowFetchForMainFrameScript(
+    const ResourceRequest& request,
+    FetchRequest::DeferOption defer,
+    Document& document,
+    std::pair<AtomicString, AtomicString>& customHeader) {
   // Only scripts inserted via document.write are candidates for having their
   // fetch disallowed.
   if (!document.isInDocumentWrite())
     return false;
 
   if (!document.settings())
     return false;
 
   if (!document.frame())
     return false;
@@ skipping 21 matching lines @@
   String documentDomain = NetworkUtils::getDomainAndRegistry(
       documentHost, NetworkUtils::IncludePrivateRegistries);
   // getDomainAndRegistry will return the empty string for domains that are
   // already top-level, such as localhost. Thus we only compare domains if we
   // get non-empty results back from getDomainAndRegistry.
   if (!requestDomain.isEmpty() && !documentDomain.isEmpty() &&
       requestDomain == documentDomain)
     return false;
 
   emitWarningForDocWriteScripts(request.url().getString(), document);
+  customHeader.first = "Intervention";
+  customHeader.second =
+      "<https://www.chromestatus.com/feature/5718547946799104>; "
+      "level=\"warning\"";
 
   // Do not block scripts if it is a page reload. This is to enable pages to
   // recover if blocking of a script is leading to a page break and the user
   // reloads the page.
   const FrameLoadType loadType = document.frame()->loader().loadType();
   if (isReloadLoadType(loadType)) {
     // Recording this metric since an increase in number of reloads for pages
     // where a script was blocked could be indicative of a page break.
     document.loader()->didObserveLoadingBehavior(
         WebLoadingBehaviorFlag::WebLoadingBehaviorDocumentWriteBlockReload);
@@ skipping 126 matching lines @@
   if (policy == CachePolicyReload)
     return WebCachePolicy::BypassingCache;
   if (policy == CachePolicyHistoryBuffer)
     return WebCachePolicy::ReturnCacheDataElseLoad;
   return WebCachePolicy::UseProtocolCachePolicy;
 }
 
 WebCachePolicy FrameFetchContext::resourceRequestCachePolicy(
     const ResourceRequest& request,
     Resource::Type type,
-    FetchRequest::DeferOption defer) const {
+    FetchRequest::DeferOption defer,
+    std::pair<AtomicString, AtomicString>& customHeader) const {
   DCHECK(frame());
   if (type == Resource::MainResource) {
     FrameLoadType frameLoadType = frame()->loader().loadType();
     if (request.httpMethod() == "POST" &&
         frameLoadType == FrameLoadTypeBackForward)
       return WebCachePolicy::ReturnCacheDataDontLoad;
     if (frameLoadType == FrameLoadTypeReloadMainResource ||
         request.isConditional() || request.httpMethod() == "POST")
       return WebCachePolicy::ValidatingCacheData;
 
@@ skipping 12 matching lines @@
     // having special kinds of FrameLoadType as they are checked inside
     // the for loop above, or |frameLoadType| being FrameLoadTypeStandard.
     // See public/web/WebFrameLoadType.h to know how these load types work.
     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() && m_document &&
-      shouldDisallowFetchForMainFrameScript(request, defer, *m_document))
+      shouldDisallowFetchForMainFrameScript(request, defer, *m_document,
+                                            customHeader))
     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();
@@ skipping 644 matching lines @@
                                                     response);
 }
 
 DEFINE_TRACE(FrameFetchContext) {
   visitor->trace(m_document);
   visitor->trace(m_documentLoader);
   FetchContext::trace(visitor);
 }
 
 }  // namespace blink