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 144 matching lines @@
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
 };
 
 scoped_refptr<ServiceWorkerRegistration> ServiceWorkerJobTest::RunRegisterJob(
     const GURL& pattern,
     const GURL& script_url,
     ServiceWorkerStatusCode expected_status) {
   scoped_refptr<ServiceWorkerRegistration> registration;
   bool called;
   job_coordinator()->Register(
-      pattern, script_url, NULL,
+      script_url, ServiceWorkerRegistrationOptions(pattern), NULL,
       SaveRegistration(expected_status, &called, &registration));
   EXPECT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   return registration;
 }
 
 void ServiceWorkerJobTest::RunUnregisterJob(
     const GURL& pattern,
     ServiceWorkerStatusCode expected_status) {
@@ skipping 71 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   ASSERT_EQ(registration1, original_registration);
   ASSERT_EQ(registration1, registration2);
 }
 
 TEST_F(ServiceWorkerJobTest, DifferentMatchDifferentRegistration) {
   bool called1;
   scoped_refptr<ServiceWorkerRegistration> original_registration1;
   job_coordinator()->Register(
-      GURL("http://www.example.com/one/"),
       GURL("http://www.example.com/service_worker.js"),
+      ServiceWorkerRegistrationOptions(GURL("http://www.example.com/one/")),
       NULL,
       SaveRegistration(SERVICE_WORKER_OK, &called1, &original_registration1));
 
   bool called2;
   scoped_refptr<ServiceWorkerRegistration> original_registration2;
   job_coordinator()->Register(
-      GURL("http://www.example.com/two/"),
       GURL("http://www.example.com/service_worker.js"),
+      ServiceWorkerRegistrationOptions(GURL("http://www.example.com/two/")),
       NULL,
       SaveRegistration(SERVICE_WORKER_OK, &called2, &original_registration2));
 
   EXPECT_FALSE(called1);
   EXPECT_FALSE(called2);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called2);
   EXPECT_TRUE(called1);
 
   scoped_refptr<ServiceWorkerRegistration> registration1;
@@ skipping 127 matching lines @@
 
 // Register and then unregister the pattern, in parallel. Job coordinator should
 // process jobs until the last job.
 TEST_F(ServiceWorkerJobTest, ParallelRegUnreg) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   bool registration_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator()->Register(
-      pattern,
-      script_url,
-      NULL,
+      script_url, ServiceWorkerRegistrationOptions(pattern), NULL,
       SaveRegistration(SERVICE_WORKER_OK, &registration_called, &registration));
 
   bool unregistration_called = false;
   job_coordinator()->Unregister(
       pattern,
       SaveUnregistration(SERVICE_WORKER_OK, &unregistration_called));
 
   ASSERT_FALSE(registration_called);
   ASSERT_FALSE(unregistration_called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(registration_called);
   ASSERT_TRUE(unregistration_called);
 
   registration = FindRegistrationForPattern(pattern,
                                             SERVICE_WORKER_ERROR_NOT_FOUND);
 
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 }
 
 // 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(
-      pattern,
-      script_url1,
-      NULL,
-      SaveRegistration(
-          SERVICE_WORKER_OK, &registration1_called, &registration1));
+      script_url1, ServiceWorkerRegistrationOptions(pattern), NULL,
+      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(
-      pattern,
-      script_url2,
-      NULL,
-      SaveRegistration(
-          SERVICE_WORKER_OK, &registration2_called, &registration2));
+      script_url2, ServiceWorkerRegistrationOptions(pattern), NULL,
+      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 =
       FindRegistrationForPattern(pattern);
 
   ASSERT_EQ(registration2, registration);
 }
 
 // Register the exact same pattern + script. Requests should be
 // coalesced such that both callers get the exact same registration
 // object.
 TEST_F(ServiceWorkerJobTest, ParallelRegSameScript) {
   GURL pattern("http://www.example.com/");
 
   GURL script_url("http://www.example.com/service_worker1.js");
   bool registration1_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator()->Register(
-      pattern,
-      script_url,
-      NULL,
-      SaveRegistration(
-          SERVICE_WORKER_OK, &registration1_called, &registration1));
+      script_url, ServiceWorkerRegistrationOptions(pattern), NULL,
+      SaveRegistration(SERVICE_WORKER_OK, &registration1_called,
+                       &registration1));
 
   bool registration2_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration2;
   job_coordinator()->Register(
-      pattern,
-      script_url,
-      NULL,
-      SaveRegistration(
-          SERVICE_WORKER_OK, &registration2_called, &registration2));
+      script_url, ServiceWorkerRegistrationOptions(pattern), NULL,
+      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);
 
   ASSERT_EQ(registration1, registration2);
 
   scoped_refptr<ServiceWorkerRegistration> registration =
@@ skipping 36 matching lines @@
 
 TEST_F(ServiceWorkerJobTest, AbortAll_Register) {
   GURL pattern1("http://www1.example.com/");
   GURL pattern2("http://www2.example.com/");
   GURL script_url1("http://www1.example.com/service_worker.js");
   GURL script_url2("http://www2.example.com/service_worker.js");
 
   bool registration_called1 = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator()->Register(
-      pattern1,
-      script_url1,
-      NULL,
-      SaveRegistration(SERVICE_WORKER_ERROR_ABORT,
-                       &registration_called1, &registration1));
+      script_url1, ServiceWorkerRegistrationOptions(pattern1), NULL,
+      SaveRegistration(SERVICE_WORKER_ERROR_ABORT, &registration_called1,
+                       &registration1));
 
   bool registration_called2 = false;
   scoped_refptr<ServiceWorkerRegistration> registration2;
   job_coordinator()->Register(
-      pattern2,
-      script_url2,
-      NULL,
-      SaveRegistration(SERVICE_WORKER_ERROR_ABORT,
-                       &registration_called2, &registration2));
+      script_url2, ServiceWorkerRegistrationOptions(pattern2), NULL,
+      SaveRegistration(SERVICE_WORKER_ERROR_ABORT, &registration_called2,
+                       &registration2));
 
   ASSERT_FALSE(registration_called1);
   ASSERT_FALSE(registration_called2);
   job_coordinator()->AbortAll();
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(registration_called1);
   ASSERT_TRUE(registration_called2);
 
   bool find_called1 = false;
@@ skipping 41 matching lines @@
   ASSERT_TRUE(unregistration_called2);
 }
 
 TEST_F(ServiceWorkerJobTest, AbortAll_RegUnreg) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   bool registration_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator()->Register(
-      pattern,
-      script_url,
-      NULL,
-      SaveRegistration(SERVICE_WORKER_ERROR_ABORT,
-                       &registration_called, &registration));
+      script_url, ServiceWorkerRegistrationOptions(pattern), NULL,
+      SaveRegistration(SERVICE_WORKER_ERROR_ABORT, &registration_called,
+                       &registration));
 
   bool unregistration_called = false;
   job_coordinator()->Unregister(
       pattern,
       SaveUnregistration(SERVICE_WORKER_ERROR_ABORT,
                          &unregistration_called));
 
   ASSERT_FALSE(registration_called);
   ASSERT_FALSE(unregistration_called);
   job_coordinator()->AbortAll();
@@ skipping 174 matching lines @@
 
   void set_force_start_worker_failure(bool force_start_worker_failure) {
     force_start_worker_failure_ = force_start_worker_failure;
   }
 
   scoped_refptr<ServiceWorkerRegistration> SetupInitialRegistration(
       const GURL& test_origin) {
     scoped_refptr<ServiceWorkerRegistration> registration;
     bool called = false;
     job_coordinator()->Register(
-        test_origin.Resolve(kScope),
         test_origin.Resolve(kScript),
-        NULL,
+        ServiceWorkerRegistrationOptions(test_origin.Resolve(kScope)), NULL,
         SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(called);
     EXPECT_TRUE(registration.get());
     EXPECT_TRUE(registration->active_version());
     EXPECT_FALSE(registration->installing_version());
     EXPECT_FALSE(registration->waiting_version());
     registration_ = registration;
     return registration;
   }
@@ skipping 896 matching lines @@
   // should not be promoted to ACTIVATED because failure occur
   // during shutdown.
   runner->RunUntilIdle();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(new_version.get(), registration->active_version());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATING, new_version->status());
   registration->RemoveListener(update_helper);
 }
 
 }  // namespace content