Service Worker: Obey content settings when deciding to control a page

content/browser/service_worker/service_worker_controllee_request_handler.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/browser/service_worker/service_worker_controllee_request_handler.h"
 
 #include "base/debug/trace_event.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_url_request_job.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/common/resource_request_body.h"
 #include "content/common/service_worker/service_worker_types.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/common/content_client.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request.h"
 
 namespace content {
 
 ServiceWorkerControlleeRequestHandler::ServiceWorkerControlleeRequestHandler(
     base::WeakPtr<ServiceWorkerContextCore> context,
     base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
@@ skipping 27 matching lines @@
     else
       provider_host_->active_version()->DeferScheduledUpdate();
   }
 
   if (is_main_resource_load_ && provider_host_)
     provider_host_->SetAllowAssociation(true);
 }
 
 net::URLRequestJob* ServiceWorkerControlleeRequestHandler::MaybeCreateJob(
     net::URLRequest* request,
-    net::NetworkDelegate* network_delegate) {
+    net::NetworkDelegate* network_delegate,
+    ResourceContext* resource_context) {
   if (!context_ || !provider_host_) {
     // We can't do anything other than to fall back to network.
     job_ = NULL;
     return NULL;
   }
 
   // This may get called multiple times for original and redirect requests:
   // A. original request case: job_ is null, no previous location info.
   // B. redirect or restarted request case:
   //  a) job_ is non-null if the previous location was forwarded to SW.
@@ skipping 12 matching lines @@
 
   job_ = new ServiceWorkerURLRequestJob(request,
                                         network_delegate,
                                         provider_host_,
                                         blob_storage_context_,
                                         request_mode_,
                                         credentials_mode_,
                                         request_context_type_,
                                         frame_type_,
                                         body_);
+  resource_context_ = resource_context;
+
   if (is_main_resource_load_)
     PrepareForMainResource(request);
   else
     PrepareForSubResource();
 
   if (job_->ShouldFallbackToNetwork()) {
     // If we know we can fallback to network at this point (in case
     // the storage lookup returned immediately), just return NULL here to
     // fallback to network.
     job_ = NULL;
@@ skipping 62 matching lines @@
     job_->FallbackToNetwork();
     TRACE_EVENT_ASYNC_END1(
         "ServiceWorker",
         "ServiceWorkerControlleeRequestHandler::PrepareForMainResource",
         job_.get(),
         "Status", status);
     return;
   }
   DCHECK(registration.get());
 
+  if (!GetContentClient()->browser()->AllowServiceWorker(
+          registration->pattern(),
+          provider_host_->topmost_frame_url(),
+          resource_context_)) {
+    job_->FallbackToNetwork();
+    TRACE_EVENT_ASYNC_END1(
+        "ServiceWorker",
+        "ServiceWorkerControlleeRequestHandler::PrepareForMainResource",
+        job_.get(),
+        "Status", status);

[michaeln, 2014/10/10 22:26:31]

I wonder if it makes sense to call host->SetAllowAssociation(false) here too and
leave it set that way for the duration, so later registration jobs won't be able
to graft a registration to this doc?

[falken, 2014/10/15 04:39:37]

Hmm, good question. But if AllowServiceWorker is on when register() is called,
it seems reasonable to let it associate with the doc?

Anyway the scenario seems unlikely: AllowServiceWorker would have to flip
between here and when register() is called (or register was already called and
queued up the job, then AllowServiceWorker flipped false, then the page load
starts, then the job runs). And this all happens before page load finishes.

Also the job only associates when it creates a new registration, which it
shouldn't since there's an existing one at this point.

[michaeln1, 2014/10/15 19:33:05]

Right, it doesn't make sense to do that.

+    return;
+  }
+
   // Initiate activation of a waiting version.
   // Usually a register job initiates activation but that
   // doesn't happen if the browser exits prior to activation
   // having occurred. This check handles that case.
   if (registration->waiting_version())
     registration->ActivateWaitingVersionWhenReady();
 
   scoped_refptr<ServiceWorkerVersion> active_version =
       registration->active_version();
 
@@ skipping 60 matching lines @@
 }
 
 void ServiceWorkerControlleeRequestHandler::PrepareForSubResource() {
   DCHECK(job_.get());
   DCHECK(context_);
   DCHECK(provider_host_->active_version());
   job_->ForwardToServiceWorker();
 }
 
 }  // namespace content