Implement updateViaCache flag and no-cache by default for main service worker scripts

content/browser/service_worker/service_worker_dispatcher_host.cc

 // Copyright 2013 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_dispatcher_host.h"
 
 #include <utility>
 
 #include "base/debug/crash_logging.h"
 #include "base/logging.h"
@@ skipping 240 matching lines @@
                                           provider_host, registration));
   ServiceWorkerRegistrationHandle* new_handle_ptr = new_handle.get();
   RegisterServiceWorkerRegistrationHandle(std::move(new_handle));
   return new_handle_ptr;
 }
 
 void ServiceWorkerDispatcherHost::OnRegisterServiceWorker(
     int thread_id,
     int request_id,
     int provider_id,
-    const GURL& pattern,
-    const GURL& script_url) {
+    const GURL& script_url,
+    const ServiceWorkerRegistrationOptions& options) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnRegisterServiceWorker");
   ProviderStatus provider_status;
   ServiceWorkerProviderHost* provider_host =
       GetProviderHostForRequest(&provider_status, provider_id);
   switch (provider_status) {
     case ProviderStatus::NO_CONTEXT:  // fallthrough
     case ProviderStatus::DEAD_HOST:
       Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
           thread_id, request_id, WebServiceWorkerError::kErrorTypeAbort,
           base::ASCIIToUTF16(kServiceWorkerRegisterErrorPrefix) +
               base::ASCIIToUTF16(kShutdownErrorMessage)));
       return;
     case ProviderStatus::NO_HOST:
       bad_message::ReceivedBadMessage(this, bad_message::SWDH_REGISTER_NO_HOST);
       return;
     case ProviderStatus::NO_URL:
       Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
           thread_id, request_id, WebServiceWorkerError::kErrorTypeSecurity,
           base::ASCIIToUTF16(kServiceWorkerRegisterErrorPrefix) +
               base::ASCIIToUTF16(kNoDocumentURLErrorMessage)));
       return;
     case ProviderStatus::OK:
       break;
   }
 
-  if (!pattern.is_valid() || !script_url.is_valid()) {
+  if (!options.scope.is_valid() || !script_url.is_valid()) {
     bad_message::ReceivedBadMessage(this, bad_message::SWDH_REGISTER_BAD_URL);
     return;
   }
 
   std::string error_message;
-  if (ServiceWorkerUtils::ContainsDisallowedCharacter(pattern, script_url,
+  if (ServiceWorkerUtils::ContainsDisallowedCharacter(options.scope, script_url,
                                                       &error_message)) {
     bad_message::ReceivedBadMessage(this, bad_message::SWDH_REGISTER_CANNOT);
     return;
   }
 
-  std::vector<GURL> urls = {provider_host->document_url(), pattern, script_url};
+  std::vector<GURL> urls = {provider_host->document_url(), options.scope,
+                            script_url};
   if (!ServiceWorkerUtils::AllOriginsMatchAndCanAccessServiceWorkers(urls)) {
     bad_message::ReceivedBadMessage(this, bad_message::SWDH_REGISTER_CANNOT);
     return;
   }
 
   if (!GetContentClient()->browser()->AllowServiceWorker(
-          pattern, provider_host->topmost_frame_url(), resource_context_,
+          options.scope, provider_host->topmost_frame_url(), resource_context_,
           base::Bind(&GetWebContents, render_process_id_,
                      provider_host->frame_id()))) {
     Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
         thread_id, request_id, WebServiceWorkerError::kErrorTypeDisabled,
         base::ASCIIToUTF16(kServiceWorkerRegisterErrorPrefix) +
             base::ASCIIToUTF16(kUserDeniedPermissionMessage)));
     return;
   }
 
-  TRACE_EVENT_ASYNC_BEGIN2(
-      "ServiceWorker", "ServiceWorkerDispatcherHost::RegisterServiceWorker",
-      request_id, "Scope", pattern.spec(), "Script URL", script_url.spec());
+  TRACE_EVENT_ASYNC_BEGIN2("ServiceWorker",
+                           "ServiceWorkerDispatcherHost::RegisterServiceWorker",
+                           request_id, "Scope", options.scope.spec(),
+                           "Script URL", script_url.spec());
   GetContext()->RegisterServiceWorker(
-      pattern,
-      script_url,
-      provider_host,
-      base::Bind(&ServiceWorkerDispatcherHost::RegistrationComplete,
-                 this,
-                 thread_id,
-                 provider_id,
-                 request_id));
+      script_url, options, provider_host,
+      base::Bind(&ServiceWorkerDispatcherHost::RegistrationComplete, this,
+                 thread_id, provider_id, request_id));
 }
 
 void ServiceWorkerDispatcherHost::OnUpdateServiceWorker(
     int thread_id,
     int request_id,
     int provider_id,
     int64_t registration_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnUpdateServiceWorker");
   ProviderStatus provider_status;
@@ skipping 1229 matching lines @@
   if (!handle) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::SWDH_TERMINATE_BAD_HANDLE);
     return;
   }
   handle->version()->StopWorker(
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 }  // namespace content