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

content/browser/service_worker/link_header_support.cc

 // Copyright 2016 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/link_header_support.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "components/link_header_util/link_header_util.h"
@@ skipping 15 matching lines @@
 namespace content {
 
 namespace {
 
 void RegisterServiceWorkerFinished(int64_t trace_id, bool result) {
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
                          "LinkHeaderResourceThrottle::HandleServiceWorkerLink",
                          trace_id, "Success", result);
 }
 
+blink::WebServiceWorkerUpdateViaCache ParseUpdateViaCache(
+    const std::unordered_map<std::string, base::Optional<std::string>>&
+        params) {
+  // https://html.spec.whatwg.org/multipage/semantics.html#attr-link-updateviacache
+  auto cache_param = params.find("updateviacache");
+  if (cache_param == params.end())
+    return blink::WebServiceWorkerUpdateViaCache::kImports;
+  const std::string& cache = cache_param->second.value_or("");
+  if (base::EqualsCaseInsensitiveASCII(cache, "imports"))
+    return blink::WebServiceWorkerUpdateViaCache::kImports;
+  if (base::EqualsCaseInsensitiveASCII(cache, "none"))
+    return blink::WebServiceWorkerUpdateViaCache::kNone;
+  if (base::EqualsCaseInsensitiveASCII(cache, "all"))
+    return blink::WebServiceWorkerUpdateViaCache::kAll;
+  return blink::WebServiceWorkerUpdateViaCache::kUnknown;
+}
+
 void HandleServiceWorkerLink(
     net::URLRequest* request,
     const std::string& url,
     const std::unordered_map<std::string, base::Optional<std::string>>& params,
     ServiceWorkerContextWrapper* service_worker_context_for_testing) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableExperimentalWebPlatformFeatures) &&
       !TrialTokenValidator::RequestEnablesFeature(request, "ForeignFetch")) {
@@ skipping 42 matching lines @@
   // should share logic with ServiceWorkerRequestHandler and
   // ForeignFetchRequestHandler to limit the requests for which serviceworker
   // links are processed.
 
   GURL context_url = request->url();
   GURL script_url = context_url.Resolve(url);
   auto scope_param = params.find("scope");
   GURL scope_url = scope_param == params.end()
                        ? script_url.Resolve("./")
                        : context_url.Resolve(scope_param->second.value_or(""));
+  blink::WebServiceWorkerUpdateViaCache update_via_cache =
+      ParseUpdateViaCache(params);
+  if (update_via_cache == blink::WebServiceWorkerUpdateViaCache::kUnknown) {
+    return;
+  }
 
   if (!context_url.is_valid() || !script_url.is_valid() ||
       !scope_url.is_valid())
     return;
   if (!ServiceWorkerUtils::AllOriginsMatchAndCanAccessServiceWorkers(
           {context_url, scope_url, script_url})) {
     return;
   }
   std::string error;
   if (ServiceWorkerUtils::ContainsDisallowedCharacter(scope_url, script_url,
                                                       &error))
     return;
 
   if (!GetContentClient()->browser()->AllowServiceWorker(
           scope_url, request->first_party_for_cookies(),
           request_info->GetContext(),
           request_info->GetWebContentsGetterForRequest()))
     return;
 
   static int64_t trace_id = 0;
   TRACE_EVENT_ASYNC_BEGIN2(
       "ServiceWorker", "LinkHeaderResourceThrottle::HandleServiceWorkerLink",
       ++trace_id, "Pattern", scope_url.spec(), "Script URL", script_url.spec());
   service_worker_context->RegisterServiceWorker(
-      scope_url, script_url,
+      scope_url, script_url, update_via_cache,
       base::Bind(&RegisterServiceWorkerFinished, trace_id));
 }
 
 void ProcessLinkHeaderValueForRequest(
     net::URLRequest* request,
     std::string::const_iterator value_begin,
     std::string::const_iterator value_end,
     ServiceWorkerContextWrapper* service_worker_context_for_testing) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 30 matching lines @@
     net::URLRequest* request,
     const std::string& link_header,
     ServiceWorkerContextWrapper* service_worker_context_for_testing) {
   for (const auto& value : link_header_util::SplitLinkHeader(link_header)) {
     ProcessLinkHeaderValueForRequest(request, value.first, value.second,
                                      service_worker_context_for_testing);
   }
 }
 
 }  // namespace content