Skip foreign fetch when the skipServiceWorker flag is set on a request.

content/child/web_url_loader_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/child/web_url_loader_impl.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 488 matching lines @@
   // the render process, so we can use requestorProcessID even for requests
   // from in-process plugins.
   request_info.requestor_pid = request.requestorProcessID();
   request_info.request_type = WebURLRequestToResourceType(request);
   request_info.priority =
       ConvertWebKitPriorityToNetPriority(request.getPriority());
   request_info.appcache_host_id = request.appCacheHostID();
   request_info.routing_id = request.requestorID();
   request_info.download_to_file = request.downloadToFile();
   request_info.has_user_gesture = request.hasUserGesture();
-  request_info.skip_service_worker = request.skipServiceWorker();
+  request_info.skip_service_worker =
+      GetSkipServiceWorkerForWebURLRequest(request);
   request_info.should_reset_appcache = request.shouldResetAppCache();
   request_info.fetch_request_mode =
       GetFetchRequestModeForWebURLRequest(request);
   request_info.fetch_credentials_mode =
       GetFetchCredentialsModeForWebURLRequest(request);
   request_info.fetch_redirect_mode =
       GetFetchRedirectModeForWebURLRequest(request);
   request_info.fetch_request_context_type =
       GetRequestContextTypeForWebURLRequest(request);
   request_info.fetch_frame_type =
@@ skipping 53 matching lines @@
       "loading", "WebURLLoaderImpl::Context::OnReceivedRedirect",
       this, TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
 
   WebURLResponse response;
   response.initialize();
   PopulateURLResponse(request_.url(), info, &response,
                       request_.reportRawHeaders());
 
   WebURLRequest new_request;
   new_request.initialize();
-  PopulateURLRequestForRedirect(request_, redirect_info, referrer_policy_,
-                                !info.was_fetched_via_service_worker,
-                                &new_request);
+  PopulateURLRequestForRedirect(
+      request_, redirect_info, referrer_policy_,
+      info.was_fetched_via_service_worker
+          ? blink::WebURLRequest::SkipServiceWorker::None
+          : blink::WebURLRequest::SkipServiceWorker::All,

[horo, 2016/06/28 12:10:02]

What should happen in this case?
1. https://example1.com is controlled by a Service Worker (SW1).
2. <img src="//example2.com/test.png"> in https://example1.com.
3. SW1 doesn't call respondWith() for the request.
4. The server (example2.com) returns a redirect response (Location:
https://example3.com/test.png).
5. example3.com has a foreign fetch Service Worker (SW2).

Should the fetch handler of SW2 be fired?

[Marijn Kruisselbrink, 2016/06/28 17:06:12]

This reminds me that I still need to write the integration with the fetch spec
for foreign fetch. But no, I think at least initially I don't think servers
redirecting should ever end up back in a service worker (in other worse, I'm
planning on using the same "skip-service-worker-flag" the fetch spec uses to
skip regular service workers to also skip foreign fetch service workers; fetch
always sets that flag on requests that weren't initially handled by a service
worker, so no redirects will end up being handled by a service worker).

+      &new_request);
 
   client_->willFollowRedirect(loader_, new_request, response);
   request_ = new_request;
 
   // Only follow the redirect if WebKit left the URL unmodified.
   if (redirect_info.new_url == GURL(new_request.url())) {
     // First-party cookie logic moved from DocumentLoader in Blink to
     // net::URLRequest in the browser. Assert that Blink didn't try to change it
     // to something else.
     DCHECK_EQ(redirect_info.new_first_party_for_cookies.spec(),
@@ skipping 469 matching lines @@
   while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
     response->addHTTPHeaderField(WebString::fromLatin1(name),
                                  WebString::fromLatin1(value));
   }
 }
 
 void WebURLLoaderImpl::PopulateURLRequestForRedirect(
     const blink::WebURLRequest& request,
     const net::RedirectInfo& redirect_info,
     blink::WebReferrerPolicy referrer_policy,
-    bool skip_service_worker,
+    blink::WebURLRequest::SkipServiceWorker skip_service_worker,
     blink::WebURLRequest* new_request) {
   // TODO(darin): We lack sufficient information to construct the actual
   // request that resulted from the redirect.
   new_request->setURL(redirect_info.new_url);
   new_request->setFirstPartyForCookies(
       redirect_info.new_first_party_for_cookies);
   new_request->setDownloadToFile(request.downloadToFile());
   new_request->setUseStreamOnResponse(request.useStreamOnResponse());
   new_request->setRequestContext(request.getRequestContext());
   new_request->setFrameType(request.getFrameType());
@@ skipping 112 matching lines @@
     response->clearHTTPHeaderField(webStringName);
     while (response_headers->EnumerateHeader(&iterator, name, &value)) {
       response->addHTTPHeaderField(webStringName,
                                    WebString::fromLatin1(value));
     }
   }
   return true;
 }
 
 }  // namespace content