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,
+bool shouldDisallowFetchForMainFrameScript(ResourceRequest& request,
                                            FetchRequest::DeferOption defer,
                                            Document& document) {
   // Only scripts inserted via document.write are candidates for having their
   // fetch disallowed.
   if (!document.isInDocumentWrite())
     return false;
 
   if (!document.settings())
     return false;
 
@@ skipping 23 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);
+  request.setHTTPHeaderField("Intervention",
+                             "<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 124 matching lines @@
   if (policy == CachePolicyRevalidate)
     return WebCachePolicy::ValidatingCacheData;
   if (policy == CachePolicyReload)
     return WebCachePolicy::BypassingCache;
   if (policy == CachePolicyHistoryBuffer)
     return WebCachePolicy::ReturnCacheDataElseLoad;
   return WebCachePolicy::UseProtocolCachePolicy;
 }
 
 WebCachePolicy FrameFetchContext::resourceRequestCachePolicy(
-    const ResourceRequest& request,
+    ResourceRequest& request,
     Resource::Type type,
     FetchRequest::DeferOption defer) 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")
@@ skipping 679 matching lines @@
                                                     response);
 }
 
 DEFINE_TRACE(FrameFetchContext) {
   visitor->trace(m_document);
   visitor->trace(m_documentLoader);
   FetchContext::trace(visitor);
 }
 
 }  // namespace blink