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

content/child/service_worker/service_worker_dispatcher.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/child/service_worker/service_worker_dispatcher.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 102 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CountFeature, OnCountFeature)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
 }
 
 void ServiceWorkerDispatcher::RegisterServiceWorker(
     int provider_id,
     const GURL& pattern,
     const GURL& script_url,
+    blink::WebServiceWorkerUpdateViaCache update_via_cache,
     std::unique_ptr<WebServiceWorkerRegistrationCallbacks> callbacks) {
   DCHECK(callbacks);
 
   if (pattern.possibly_invalid_spec().size() > url::kMaxURLChars ||
       script_url.possibly_invalid_spec().size() > url::kMaxURLChars) {
     std::string error_message(kServiceWorkerRegisterErrorPrefix);
     error_message += "The provided scriptURL or scope is too long.";
     callbacks->OnError(
         WebServiceWorkerError(WebServiceWorkerError::kErrorTypeSecurity,
                               blink::WebString::FromASCII(error_message)));
     return;
   }
 
   int request_id = pending_registration_callbacks_.Add(std::move(callbacks));
-  ServiceWorkerRegistrationOptions options(pattern);
+  ServiceWorkerRegistrationOptions options(pattern, update_via_cache);
 
   TRACE_EVENT_ASYNC_BEGIN2("ServiceWorker",
                            "ServiceWorkerDispatcher::RegisterServiceWorker",
                            request_id,
                            "Scope", pattern.spec(),
                            "Script URL", script_url.spec());
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_RegisterServiceWorker(
       CurrentWorkerId(), request_id, provider_id, script_url, options));
 }
 
@@ skipping 30 matching lines @@
     std::string error_message(kServiceWorkerGetRegistrationErrorPrefix);
     error_message += "The provided documentURL is too long.";
     callbacks->OnError(
         WebServiceWorkerError(WebServiceWorkerError::kErrorTypeSecurity,
                               blink::WebString::FromASCII(error_message)));
     return;
   }
 
   int request_id =
       pending_get_registration_callbacks_.Add(std::move(callbacks));
+
   TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker",
                            "ServiceWorkerDispatcher::GetRegistration",
                            request_id,
                            "Document URL", document_url.spec());
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetRegistration(
       CurrentWorkerId(), request_id, provider_id, document_url));
 }
 
 void ServiceWorkerDispatcher::GetRegistrations(
     int provider_id,
@@ skipping 167 matching lines @@
   std::unique_ptr<ServiceWorkerRegistrationHandleReference> registration_ref =
       Adopt(info);
   std::unique_ptr<ServiceWorkerHandleReference> installing_ref =
       Adopt(attrs.installing);
   std::unique_ptr<ServiceWorkerHandleReference> waiting_ref =
       Adopt(attrs.waiting);
   std::unique_ptr<ServiceWorkerHandleReference> active_ref =
       Adopt(attrs.active);
 
   RegistrationObjectMap::iterator found = registrations_.find(info.handle_id);
-  if (found != registrations_.end())
+  if (found != registrations_.end()) {
+    if (found->second->UpdateViaCache() != registration_ref->update_via_cache())
+      found->second->SetRegistrationHandleReference(
+          std::move(registration_ref));
     return found->second;
+  }
 
   // WebServiceWorkerRegistrationImpl constructor calls
   // AddServiceWorkerRegistration.
   scoped_refptr<WebServiceWorkerRegistrationImpl> registration(
       new WebServiceWorkerRegistrationImpl(std::move(registration_ref)));
   registration->SetInstalling(
       GetOrCreateServiceWorker(std::move(installing_ref)));
   registration->SetWaiting(GetOrCreateServiceWorker(std::move(waiting_ref)));
   registration->SetActive(GetOrCreateServiceWorker(std::move(active_ref)));
   return registration;
@@ skipping 537 matching lines @@
   return ServiceWorkerRegistrationHandleReference::Adopt(
       info, thread_safe_sender_.get());
 }
 
 std::unique_ptr<ServiceWorkerHandleReference> ServiceWorkerDispatcher::Adopt(
     const ServiceWorkerObjectInfo& info) {
   return ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get());
 }
 
 }  // namespace content