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

content/browser/service_worker/service_worker_job_unittest.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 <stdint.h>
 #include <tuple>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 195 matching lines @@
     return job_coordinator()->job_timeout_timer_.IsRunning();
   }
 
   ServiceWorkerStorage* storage() const { return context()->storage(); }
 
  protected:
   scoped_refptr<ServiceWorkerRegistration> RunRegisterJob(
       const GURL& pattern,
       const GURL& script_url,
       ServiceWorkerStatusCode expected_status = SERVICE_WORKER_OK);
+  scoped_refptr<ServiceWorkerRegistration> RunRegisterJob(
+      const GURL& script_url,
+      const ServiceWorkerRegistrationOptions& options,
+      ServiceWorkerStatusCode expected_status = SERVICE_WORKER_OK);
   void RunUnregisterJob(
       const GURL& pattern,
       ServiceWorkerStatusCode expected_status = SERVICE_WORKER_OK);
   scoped_refptr<ServiceWorkerRegistration> FindRegistrationForPattern(
       const GURL& pattern,
       ServiceWorkerStatusCode expected_status = SERVICE_WORKER_OK);
   std::unique_ptr<ServiceWorkerProviderHost> CreateControllee();
   void TimeOutFirstJob();
 
   TestBrowserThreadBundle browser_thread_bundle_;
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
   std::vector<ServiceWorkerRemoteProviderEndpoint> remote_endpoints_;
 };
 
 scoped_refptr<ServiceWorkerRegistration> ServiceWorkerJobTest::RunRegisterJob(
-    const GURL& pattern,
     const GURL& script_url,
+    const ServiceWorkerRegistrationOptions& options,
     ServiceWorkerStatusCode expected_status) {
   scoped_refptr<ServiceWorkerRegistration> registration;
   bool called;
   job_coordinator()->Register(
-      script_url, ServiceWorkerRegistrationOptions(pattern), nullptr,
+      script_url, options, nullptr,
       SaveRegistration(expected_status, &called, &registration));
   EXPECT_TRUE(is_job_timer_running());
   EXPECT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   EXPECT_FALSE(is_job_timer_running());
   return registration;
 }
 
+scoped_refptr<ServiceWorkerRegistration> ServiceWorkerJobTest::RunRegisterJob(
+    const GURL& pattern,
+    const GURL& script_url,
+    ServiceWorkerStatusCode expected_status) {
+  return RunRegisterJob(script_url, ServiceWorkerRegistrationOptions(pattern),
+                        expected_status);
+}
+
 void ServiceWorkerJobTest::RunUnregisterJob(
     const GURL& pattern,
     ServiceWorkerStatusCode expected_status) {
   bool called;
   job_coordinator()->Unregister(pattern,
                                 SaveUnregistration(expected_status, &called));
   EXPECT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 }
@@ skipping 297 matching lines @@
   ASSERT_EQ(old_registration, new_registration);
 
   ASSERT_FALSE(old_registration->HasOneRef());
 
   scoped_refptr<ServiceWorkerRegistration> new_registration_by_pattern =
       FindRegistrationForPattern(pattern);
 
   ASSERT_EQ(new_registration, old_registration);
 }
 
+// Make sure that when registering a duplicate pattern+script_url with a
+// different update_via_cache value, that the value is updated.
+TEST_F(ServiceWorkerJobTest, RegisterWithDifferentUpdateViaCache) {
+  // During registration, handles will be created for hosting the worker's
+  // context. KeepHandlesDispatcherHost will store the handles.
+  scoped_refptr<KeepHandlesDispatcherHost> dispatcher_host =
+      new KeepHandlesDispatcherHost(
+          helper_->mock_render_process_id(),
+          helper_->browser_context()->GetResourceContext());
+  helper_->RegisterDispatcherHost(helper_->mock_render_process_id(),
+                                  dispatcher_host);
+  dispatcher_host->Init(helper_->context_wrapper());
+
+  GURL pattern("http://www.example.com/");
+  GURL script_url("http://www.example.com/service_worker.js");
+  ServiceWorkerRegistrationOptions options(pattern);
+
+  scoped_refptr<ServiceWorkerRegistration> old_registration =
+      RunRegisterJob(script_url, options);
+
+  ASSERT_EQ(blink::WebServiceWorkerUpdateViaCache::kImports,
+            old_registration->update_via_cache());
+
+  // Ensure that the registration's handle doesn't have the reference.
+  EXPECT_EQ(1UL, dispatcher_host->registration_handles().size());
+  dispatcher_host->RemoveHandles();
+  EXPECT_EQ(0UL, dispatcher_host->registration_handles().size());
+  ASSERT_TRUE(old_registration->HasOneRef());
+
+  scoped_refptr<ServiceWorkerRegistration> old_registration_by_pattern =
+      FindRegistrationForPattern(pattern);
+
+  ASSERT_TRUE(old_registration_by_pattern.get());
+
+  options.update_via_cache = blink::WebServiceWorkerUpdateViaCache::kNone;
+  scoped_refptr<ServiceWorkerRegistration> new_registration =
+      RunRegisterJob(script_url, options);
+
+  ASSERT_EQ(old_registration, new_registration);
+  ASSERT_EQ(blink::WebServiceWorkerUpdateViaCache::kNone,
+            new_registration->update_via_cache());
+
+  ASSERT_FALSE(old_registration->HasOneRef());
+
+  scoped_refptr<ServiceWorkerRegistration> new_registration_by_pattern =
+      FindRegistrationForPattern(pattern);
+
+  ASSERT_EQ(new_registration, old_registration);
+}
+
 class FailToStartWorkerTestHelper : public EmbeddedWorkerTestHelper {
  public:
   FailToStartWorkerTestHelper() : EmbeddedWorkerTestHelper(base::FilePath()) {}
 
   void OnStartWorker(
       int embedded_worker_id,
       int64_t service_worker_version_id,
       const GURL& scope,
       const GURL& script_url,
       bool pause_after_download,
@@ skipping 51 matching lines @@
 // Register conflicting scripts for the same pattern. The most recent
 // registration should win, and the old registration should have been
 // shutdown.
 TEST_F(ServiceWorkerJobTest, ParallelRegNewScript) {
   GURL pattern("http://www.example.com/");
 
   GURL script_url1("http://www.example.com/service_worker1.js");
   bool registration1_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator()->Register(
-      script_url1, ServiceWorkerRegistrationOptions(pattern), nullptr,
+      script_url1,
+      ServiceWorkerRegistrationOptions(
+          pattern, blink::WebServiceWorkerUpdateViaCache::kNone),
+      nullptr,
       SaveRegistration(SERVICE_WORKER_OK, &registration1_called,
                        &registration1));
 
   GURL script_url2("http://www.example.com/service_worker2.js");
   bool registration2_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration2;
   job_coordinator()->Register(
-      script_url2, ServiceWorkerRegistrationOptions(pattern), nullptr,
+      script_url2,
+      ServiceWorkerRegistrationOptions(
+          pattern, blink::WebServiceWorkerUpdateViaCache::kAll),
+      nullptr,
       SaveRegistration(SERVICE_WORKER_OK, &registration2_called,
                        &registration2));
 
   ASSERT_FALSE(registration1_called);
   ASSERT_FALSE(registration2_called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(registration1_called);
   ASSERT_TRUE(registration2_called);
 
   scoped_refptr<ServiceWorkerRegistration> registration =
@@ skipping 1273 matching lines @@
   // should not be promoted to ACTIVATED because failure occur
   // during shutdown.
   runner->RunPendingTasks();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(new_version.get(), registration->active_version());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATING, new_version->status());
   registration->RemoveListener(update_helper);
 }
 
 }  // namespace content