ServiceWorker: Set flag to validate cache in update check request

When taking update check, request's validate cache flag should be set
depending on the conditions like update via cache option, time elapsed
since last update, etc.

Bug: 648295
Change-Id: Id2de38a65d8eccc393c1c7c40b8f82894ec52093
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1560905
Commit-Queue: Ting Shao <ting.shao@intel.com>
Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#662510}

content/browser/service_worker/service_worker_new_script_loader.cc

@@ -123,10 +123,9 @@ ServiceWorkerNewScriptLoader::ServiceWorkerNewScriptLoader(
   // hours passed since the last update check that hit network.
   base::TimeDelta time_since_last_check =
       base::Time::Now() - registration->last_update_check();
-  if (ServiceWorkerUtils::ShouldBypassCacheDueToUpdateViaCache(
-          is_main_script, registration->update_via_cache()) ||
-      time_since_last_check > kServiceWorkerScriptMaxCacheAge ||
-      version_->force_bypass_cache_for_scripts()) {
+  if (ServiceWorkerUtils::ShouldValidateBrowserCacheForScript(
+          is_main_script, version_->force_bypass_cache_for_scripts(),
+          registration->update_via_cache(), time_since_last_check)) {
     resource_request.load_flags |= net::LOAD_VALIDATE_CACHE;
   }
 

content/browser/service_worker/service_worker_register_job.cc

@@ -326,6 +326,8 @@ void ServiceWorkerRegisterJob::TriggerUpdateCheckInBrowser(
   DCHECK_EQ(GetUpdateCheckType(),
             UpdateCheckType::kAllScriptsBeforeStartWorker);
   ServiceWorkerVersion* version_to_update = registration()->GetNewestVersion();
+  base::TimeDelta time_since_last_check =
+      base::Time::Now() - registration()->last_update_check();
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   version_to_update->script_cache_map()->GetResources(&resources);
   int64_t script_resource_id =
@@ -334,7 +336,9 @@ void ServiceWorkerRegisterJob::TriggerUpdateCheckInBrowser(
 
   update_checker_ = std::make_unique<ServiceWorkerUpdateChecker>(
       std::move(resources), script_url_, script_resource_id, version_to_update,
-      context_->loader_factory_getter()->GetNetworkFactory());
+      context_->loader_factory_getter()->GetNetworkFactory(),
+      force_bypass_cache_, registration()->update_via_cache(),
+      time_since_last_check);
   update_checker_->Start(std::move(callback));
 }
 

content/browser/service_worker/service_worker_single_script_update_checker.cc

@@ -9,9 +9,11 @@
 #include "base/bind.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/service_worker/service_worker_cache_writer.h"
+#include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/resource_type.h"
 #include "mojo/public/cpp/system/simple_watcher.h"
 #include "net/base/ip_endpoint.h"
+#include "net/base/load_flags.h"
 #include "services/network/public/cpp/net_adapters.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "third_party/blink/public/common/mime_util/mime_util.h"
@@ -68,12 +70,18 @@ namespace content {
 ServiceWorkerSingleScriptUpdateChecker::ServiceWorkerSingleScriptUpdateChecker(
     const GURL& url,
     bool is_main_script,
+    bool force_bypass_cache,
+    blink::mojom::ServiceWorkerUpdateViaCache update_via_cache,
+    base::TimeDelta time_since_last_check,
     scoped_refptr<network::SharedURLLoaderFactory> loader_factory,
     std::unique_ptr<ServiceWorkerResponseReader> compare_reader,
     std::unique_ptr<ServiceWorkerResponseReader> copy_reader,
     std::unique_ptr<ServiceWorkerResponseWriter> writer,
     ResultCallback callback)
     : script_url_(url),
+      force_bypass_cache_(force_bypass_cache),
+      update_via_cache_(update_via_cache),
+      time_since_last_check_(time_since_last_check),
       network_client_binding_(this),
       network_watcher_(FROM_HERE,
                        mojo::SimpleWatcher::ArmingPolicy::MANUAL,
@@ -88,7 +96,11 @@ ServiceWorkerSingleScriptUpdateChecker::ServiceWorkerSingleScriptUpdateChecker(
   if (is_main_script)
     resource_request.headers.SetHeader("Service-Worker", "script");
 
-  // TODO(momohatt): Handle cases where force_bypass_cache is enabled.
+  if (ServiceWorkerUtils::ShouldValidateBrowserCacheForScript(
+          is_main_script, force_bypass_cache_, update_via_cache_,
+          time_since_last_check_)) {
+    resource_request.load_flags |= net::LOAD_VALIDATE_CACHE;
+  }
 
   cache_writer_ = ServiceWorkerCacheWriter::CreateForComparison(
       std::move(compare_reader), std::move(copy_reader), std::move(writer),

content/browser/service_worker/service_worker_single_script_update_checker.h

@@ -10,6 +10,7 @@
 #include "content/common/content_export.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/network/public/mojom/url_loader.mojom.h"
+#include "third_party/blink/public/mojom/service_worker/service_worker_registration.mojom.h"
 
 namespace network {
 class MojoToNetPendingBuffer;
@@ -75,6 +76,9 @@ class CONTENT_EXPORT ServiceWorkerSingleScriptUpdateChecker
   ServiceWorkerSingleScriptUpdateChecker(
       const GURL& url,
       bool is_main_script,
+      bool force_bypass_cache,
+      blink::mojom::ServiceWorkerUpdateViaCache update_via_cache,
+      base::TimeDelta time_since_last_check,
       scoped_refptr<network::SharedURLLoaderFactory> loader_factory,
       std::unique_ptr<ServiceWorkerResponseReader> compare_reader,
       std::unique_ptr<ServiceWorkerResponseReader> copy_reader,
@@ -115,6 +119,9 @@ class CONTENT_EXPORT ServiceWorkerSingleScriptUpdateChecker
   void Finish(Result result);
 
   const GURL script_url_;
+  const bool force_bypass_cache_;
+  const blink::mojom::ServiceWorkerUpdateViaCache update_via_cache_;
+  const base::TimeDelta time_since_last_check_;
 
   network::mojom::URLLoaderPtr network_loader_;
   mojo::Binding<network::mojom::URLLoaderClient> network_client_binding_;

content/browser/service_worker/service_worker_update_checker.cc

@@ -16,12 +16,18 @@ ServiceWorkerUpdateChecker::ServiceWorkerUpdateChecker(
     const GURL& main_script_url,
     int64_t main_script_resource_id,
     scoped_refptr<ServiceWorkerVersion> version_to_update,
-    scoped_refptr<network::SharedURLLoaderFactory> loader_factory)
+    scoped_refptr<network::SharedURLLoaderFactory> loader_factory,
+    bool force_bypass_cache,
+    blink::mojom::ServiceWorkerUpdateViaCache update_via_cache,
+    base::TimeDelta time_since_last_check)
     : scripts_to_compare_(std::move(scripts_to_compare)),
       main_script_url_(main_script_url),
       main_script_resource_id_(main_script_resource_id),
       version_to_update_(std::move(version_to_update)),
       loader_factory_(std::move(loader_factory)),
+      force_bypass_cache_(force_bypass_cache),
+      update_via_cache_(update_via_cache),
+      time_since_last_check_(time_since_last_check),
       weak_factory_(this) {}
 
 ServiceWorkerUpdateChecker::~ServiceWorkerUpdateChecker() = default;
@@ -96,7 +102,8 @@ void ServiceWorkerUpdateChecker::CheckOneScript(const GURL& url,
 
   auto writer = storage->CreateResponseWriter(storage->NewResourceId());
   running_checker_ = std::make_unique<ServiceWorkerSingleScriptUpdateChecker>(
-      url, is_main_script, loader_factory_, std::move(compare_reader),
+      url, is_main_script, force_bypass_cache_, update_via_cache_,
+      time_since_last_check_, loader_factory_, std::move(compare_reader),
       std::move(copy_reader), std::move(writer),
       base::BindOnce(&ServiceWorkerUpdateChecker::OnOneUpdateCheckFinished,
                      weak_factory_.GetWeakPtr(), resource_id));

content/browser/service_worker/service_worker_update_checker.h

@@ -51,7 +51,10 @@ class CONTENT_EXPORT ServiceWorkerUpdateChecker {
       const GURL& main_script_url,
       int64_t main_script_resource_id,
       scoped_refptr<ServiceWorkerVersion> version_to_update,
-      scoped_refptr<network::SharedURLLoaderFactory> loader_factory);
+      scoped_refptr<network::SharedURLLoaderFactory> loader_factory,
+      bool force_bypass_cache,
+      blink::mojom::ServiceWorkerUpdateViaCache update_via_cache,
+      base::TimeDelta time_since_last_check);
   ~ServiceWorkerUpdateChecker();
 
   // |callback| is always triggered when Start() finishes. If the scripts are
@@ -87,6 +90,11 @@ class CONTENT_EXPORT ServiceWorkerUpdateChecker {
   UpdateStatusCallback callback_;
 
   scoped_refptr<network::SharedURLLoaderFactory> loader_factory_;
+
+  const bool force_bypass_cache_;
+  const blink::mojom::ServiceWorkerUpdateViaCache update_via_cache_;
+  const base::TimeDelta time_since_last_check_;
+
   base::WeakPtrFactory<ServiceWorkerUpdateChecker> weak_factory_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ServiceWorkerUpdateChecker);

content/common/service_worker/service_worker_utils.cc

@@ -194,6 +194,16 @@ bool ServiceWorkerUtils::ShouldBypassCacheDueToUpdateViaCache(
   return false;
 }
 
+bool ServiceWorkerUtils::ShouldValidateBrowserCacheForScript(
+    bool is_main_script,
+    bool force_bypass_cache,
+    blink::mojom::ServiceWorkerUpdateViaCache cache_mode,
+    base::TimeDelta time_since_last_check) {
+  return (ShouldBypassCacheDueToUpdateViaCache(is_main_script, cache_mode) ||
+          time_since_last_check > kServiceWorkerScriptMaxCacheAge ||
+          force_bypass_cache);
+}
+
 // static
 blink::mojom::FetchCacheMode ServiceWorkerUtils::GetCacheModeFromLoadFlags(
     int load_flags) {

content/common/service_worker/service_worker_utils.h

@@ -69,6 +69,12 @@ class ServiceWorkerUtils {
       bool is_main_script,
       blink::mojom::ServiceWorkerUpdateViaCache cache_mode);
 
+  static bool ShouldValidateBrowserCacheForScript(
+      bool is_main_script,
+      bool force_bypass_cache,
+      blink::mojom::ServiceWorkerUpdateViaCache cache_mode,
+      base::TimeDelta time_since_last_check);
+
   // Converts an enum defined in net/base/load_flags.h to
   // blink::mojom::FetchCacheMode.
   CONTENT_EXPORT static blink::mojom::FetchCacheMode GetCacheModeFromLoadFlags(