ServiceWorker: Bypass SW when the script doesn't have fetch handler

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 <memory>
 #include <string>
 
 #include "base/trace_event/trace_event.h"
@@ skipping 234 matching lines @@
         "ServiceWorkerControlleeRequestHandler::PrepareForMainResource",
         job_.get(),
         "Status", status,
         "Info",
         "ServiceWorkerVersion is not available, so falling back to network");
     return;
   }
 
   ServiceWorkerMetrics::CountControlledPageLoad(stripped_url_);
 
-  job_->ForwardToServiceWorker();
+  if (!active_version->has_fetch_handler())
+    job_->FallbackToNetwork();
+  else
+    job_->ForwardToServiceWorker();
+
   TRACE_EVENT_ASYNC_END2(
       "ServiceWorker",
       "ServiceWorkerControlleeRequestHandler::PrepareForMainResource",
       job_.get(),
       "Status", status,
       "Info",
       "Forwarded to the ServiceWorker");
 }
 
 void ServiceWorkerControlleeRequestHandler::OnVersionStatusChanged(
     ServiceWorkerRegistration* registration,
     ServiceWorkerVersion* version) {
   // The job may have been canceled and then destroyed before this was invoked.
   if (!job_)
     return;
 
   if (provider_host_)
     provider_host_->SetAllowAssociation(true);
   if (version != registration->active_version() ||
       version->status() != ServiceWorkerVersion::ACTIVATED ||
       !provider_host_) {
     job_->FallbackToNetwork();
     return;
   }
 
   ServiceWorkerMetrics::CountControlledPageLoad(stripped_url_);
 
   provider_host_->AssociateRegistration(registration,
                                         false /* notify_controllerchange */);
-  job_->ForwardToServiceWorker();
+
+  if (!version->has_fetch_handler())
+    job_->FallbackToNetwork();
+  else
+    job_->ForwardToServiceWorker();
 }
 
 void ServiceWorkerControlleeRequestHandler::DidUpdateRegistration(
     const scoped_refptr<ServiceWorkerRegistration>& original_registration,
     ServiceWorkerStatusCode status,
     const std::string& status_message,
     int64_t registration_id) {
   DCHECK(force_update_started_);
 
   // The job may have been canceled and then destroyed before this was invoked.
@@ skipping 49 matching lines @@
   }
   version->RegisterStatusChangeCallback(
       base::Bind(&self::OnUpdatedVersionStatusChanged,
                  weak_factory_.GetWeakPtr(), registration, version));
 }
 
 void ServiceWorkerControlleeRequestHandler::PrepareForSubResource() {
   DCHECK(job_.get());
   DCHECK(context_);
   DCHECK(provider_host_->active_version());
-  job_->ForwardToServiceWorker();
+  if (!provider_host_->active_version()->has_fetch_handler())
+    job_->FallbackToNetwork();
+  else
+    job_->ForwardToServiceWorker();

[falken, 2016/05/27 09:53:34]

Can you factor out these three blocks into a helper function?

(Another option may be to skip the SW machinery completely by having 
ServiceWorkerProviderHost::CreateRequestHandler check if the controlling version
has a fetch handler. That may be faster than creating this job that will just
bail out. However, if we do that, the update scheduler in
~ServiceWorkerControlleeRequestHandler won't run for subresources. So possibly
the page load time is hurt by the update job. That could be worked around by
having CreateRequestHandler call DeferScheduleUpdate though, but that's getting
a bit ugly.)

[shimazu, 2016/05/30 05:41:59]

I roughly checked the performance improvements by implementing this and browsing
some pages w/o fetch handler with DevTools, but there seems to be no visible
improvements of performance, so I think it's better to take cleanness of codes.

Done.

 }
 
 void ServiceWorkerControlleeRequestHandler::OnPrepareToRestart() {
   use_network_ = true;
   ClearJob();
 }
 
 ServiceWorkerVersion*
 ServiceWorkerControlleeRequestHandler::GetServiceWorkerVersion(
     ServiceWorkerMetrics::URLRequestJobResult* result) {
@@ skipping 23 matching lines @@
   DCHECK(provider_host_);
   // Detach the controller so subresource requests also skip the worker.
   provider_host_->NotifyControllerLost();
 }
 
 void ServiceWorkerControlleeRequestHandler::ClearJob() {
   job_.reset();
 }
 
 }  // namespace content