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

content/browser/service_worker/service_worker_context_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_context_request_handler.h"
 
 #include "base/time/time.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_read_from_cache_job.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/browser/service_worker/service_worker_write_to_cache_job.h"
 #include "content/public/common/resource_response_info.h"
 #include "net/base/load_flags.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_error_job.h"
 
 namespace content {
 
+namespace {
+bool ShouldBypassCache(bool is_main_script,
+                       blink::WebServiceWorkerUpdateViaCache cache_mode) {
+  if (is_main_script &&
+      cache_mode != blink::WebServiceWorkerUpdateViaCache::kAll)
+    return true;
+  if (cache_mode == blink::WebServiceWorkerUpdateViaCache::kNone)
+    return true;
+  return false;
+}
+}  // namespace
+
 ServiceWorkerContextRequestHandler::ServiceWorkerContextRequestHandler(
     base::WeakPtr<ServiceWorkerContextCore> context,
     base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     ResourceType resource_type)
     : ServiceWorkerRequestHandler(context,
                                   provider_host,
                                   blob_storage_context,
                                   resource_type),
       version_(provider_host_->running_hosted_version()) {
@@ skipping 150 matching lines @@
   if (resource_id == kInvalidServiceWorkerResourceId) {
     *out_status = CreateJobStatus::ERROR_OUT_OF_RESOURCE_IDS;
     return nullptr;
   }
 
   // Bypass the browser cache for initial installs and update checks after 24
   // hours have passed.
   int extra_load_flags = 0;
   base::TimeDelta time_since_last_check =
       base::Time::Now() - registration->last_update_check();
-  if (time_since_last_check > kServiceWorkerScriptMaxCacheAge ||
+
+  if (ShouldBypassCache(is_main_script, registration->update_via_cache()) ||
+      time_since_last_check > kServiceWorkerScriptMaxCacheAge ||
       version_->force_bypass_cache_for_scripts()) {
     extra_load_flags = net::LOAD_BYPASS_CACHE;
   }
 
   ServiceWorkerVersion* stored_version = registration->waiting_version()
                                              ? registration->waiting_version()
                                              : registration->active_version();
   int64_t incumbent_resource_id = kInvalidServiceWorkerResourceId;
   if (is_main_script) {
     if (stored_version && stored_version->script_url() == request->url()) {
       incumbent_resource_id =
           stored_version->script_cache_map()->LookupResourceId(request->url());
     }
     version_->embedded_worker()->OnURLJobCreatedForMainScript();
   }
   *out_status = incumbent_resource_id == kInvalidServiceWorkerResourceId
                     ? CreateJobStatus::WRITE_JOB
                     : CreateJobStatus::WRITE_JOB_WITH_INCUMBENT;
   return new ServiceWorkerWriteToCacheJob(
       request, network_delegate, resource_type_, context_, version_.get(),
       extra_load_flags, resource_id, incumbent_resource_id);
 }
 
 }  // namespace content