Effectively disable foreign fetch when third party cookies are disabled.

content/browser/service_worker/foreign_fetch_request_handler.cc

 // Copyright 2015 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/browser/service_worker/foreign_fetch_request_handler.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_response_info.h"
 #include "content/browser/service_worker/service_worker_url_request_job.h"
 #include "content/common/resource_request_body_impl.h"
 #include "content/common/service_worker/service_worker_utils.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/resource_request_info.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/origin_trial_policy.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "storage/browser/blob/blob_storage_context.h"
 
 namespace content {
 
 namespace {
@@ skipping 126 matching lines @@
 
   // It's for original request (A) or redirect case (B-a or B-b).
   DCHECK(!job_.get() || job_->ShouldForwardToServiceWorker());
 
   ServiceWorkerURLRequestJob* job = new ServiceWorkerURLRequestJob(
       request, network_delegate, std::string(), blob_storage_context_,
       resource_context, request_mode_, credentials_mode_, redirect_mode_,
       resource_type_, request_context_type_, frame_type_, body_,
       ServiceWorkerFetchType::FOREIGN_FETCH, this);
   job_ = job->GetWeakPtr();
+  resource_context_ = resource_context;
 
   context_->FindReadyRegistrationForDocument(
       request->url(),
       base::Bind(&ForeignFetchRequestHandler::DidFindRegistration,
                  weak_factory_.GetWeakPtr(), job_));
 
   return job_.get();
 }
 
 ForeignFetchRequestHandler::ForeignFetchRequestHandler(
@@ skipping 48 matching lines @@
   for (const url::Origin& origin : active_version->foreign_fetch_origins()) {
     if (request_origin.IsSameOriginWith(origin))
       origin_matches = true;
   }
 
   if (!scope_matches || !origin_matches) {
     job->FallbackToNetwork();
     return;
   }
 
+  int render_process_id;
+  int render_frame_id;
+  if (!ResourceRequestInfo::GetRenderFrameForRequest(
+          job->request(), &render_process_id, &render_frame_id)) {
+    render_process_id = -1;
+    render_frame_id = -1;
+  }
+  if (!GetContentClient()->browser()->AllowServiceWorker(
+          registration->pattern(), job->request()->first_party_for_cookies(),
+          resource_context_, render_process_id, render_frame_id)) {
+    job->FallbackToNetwork();
+    return;
+  }
+
   target_worker_ = active_version;
   job->ForwardToServiceWorker();
 }
 
 void ForeignFetchRequestHandler::OnPrepareToRestart() {
   use_network_ = true;
   ClearJob();
 }
 
 ServiceWorkerVersion* ForeignFetchRequestHandler::GetServiceWorkerVersion(
     ServiceWorkerMetrics::URLRequestJobResult* result) {
   // TODO(mek): Figure out what should happen if the active worker changes or
   // gets uninstalled before this point is reached.
   if (!target_worker_) {
     *result = ServiceWorkerMetrics::REQUEST_JOB_ERROR_NO_ACTIVE_VERSION;
     return nullptr;
   }
   return target_worker_.get();
 }
 
 void ForeignFetchRequestHandler::ClearJob() {
   job_.reset();
   target_worker_ = nullptr;
+  resource_context_ = nullptr;
 }
 
 }  // namespace content