Introduce ServiceWorkerRegistrationOptions struct for service worker options

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 165 matching lines @@
   std::vector<ServiceWorkerRemoteProviderEndpoint> remote_endpoints_;
 };
 
 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), nullptr,
       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 49 matching lines @@
   ASSERT_TRUE(registration1.get());
   ASSERT_EQ(registration1, original_registration);
   ASSERT_EQ(registration1, registration2);
 }
 
 TEST_F(ServiceWorkerJobTest, SameMatchSameRegistration) {
   bool called;
   scoped_refptr<ServiceWorkerRegistration> original_registration =
       RunRegisterJob(GURL("http://www.example.com/"),
                      GURL("http://www.example.com/service_worker.js"));
-  ASSERT_NE(static_cast<ServiceWorkerRegistration*>(NULL),
+  ASSERT_NE(static_cast<ServiceWorkerRegistration*>(nullptr),
             original_registration.get());
 
   scoped_refptr<ServiceWorkerRegistration> registration1;
   storage()->FindRegistrationForDocument(
       GURL("http://www.example.com/one"),
       SaveFoundRegistration(SERVICE_WORKER_OK, &called, &registration1));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
   scoped_refptr<ServiceWorkerRegistration> registration2;
   storage()->FindRegistrationForDocument(
       GURL("http://www.example.com/two"),
       SaveFoundRegistration(SERVICE_WORKER_OK, &called, &registration2));
   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"),
-      NULL,
+      ServiceWorkerRegistrationOptions(GURL("http://www.example.com/one/")),
+      nullptr,
       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"),
-      NULL,
+      ServiceWorkerRegistrationOptions(GURL("http://www.example.com/two/")),
+      nullptr,
       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;
   storage()->FindRegistrationForDocument(
@@ skipping 27 matching lines @@
 };
 
 // Make sure basic registration is working.
 TEST_F(ServiceWorkerJobTest, Register) {
   helper_.reset(new RegisterForeignFetchTestHelper);
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       RunRegisterJob(GURL("http://www.example.com/"),
                      GURL("http://www.example.com/service_worker.js"));
 
-  ASSERT_NE(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
+  ASSERT_NE(scoped_refptr<ServiceWorkerRegistration>(nullptr), registration);
   EXPECT_EQ(EmbeddedWorkerTestHelper::Event::Install,
             helper_->dispatched_events()->at(0));
   EXPECT_EQ(EmbeddedWorkerTestHelper::Event::Activate,
             helper_->dispatched_events()->at(1));
 
   GURL valid_scope_1("http://www.example.com/test/subscope");
   GURL valid_scope_2("http://www.example.com/test/othersubscope");
   url::Origin valid_origin(GURL("https://chromium.org/"));
 
   ServiceWorkerVersion* version_ = registration->active_version();
@@ skipping 11 matching lines @@
   scoped_refptr<ServiceWorkerRegistration> registration =
       RunRegisterJob(pattern, GURL("http://www.example.com/service_worker.js"));
 
   RunUnregisterJob(pattern);
 
   ASSERT_TRUE(registration->HasOneRef());
 
   registration = FindRegistrationForPattern(pattern,
                                             SERVICE_WORKER_ERROR_NOT_FOUND);
 
-  ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
+  ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(nullptr), registration);
 }
 
 TEST_F(ServiceWorkerJobTest, Unregister_NothingRegistered) {
   GURL pattern("http://www.example.com/");
 
   RunUnregisterJob(pattern, SERVICE_WORKER_ERROR_NOT_FOUND);
 }
 
 // Make sure registering a new script creates a new version and shares an
 // existing registration.
 TEST_F(ServiceWorkerJobTest, RegisterNewScript) {
   GURL pattern("http://www.example.com/");
 
   scoped_refptr<ServiceWorkerRegistration> old_registration =
       RunRegisterJob(pattern, GURL("http://www.example.com/service_worker.js"));
 
   scoped_refptr<ServiceWorkerRegistration> old_registration_by_pattern =
       FindRegistrationForPattern(pattern);
 
   ASSERT_EQ(old_registration, old_registration_by_pattern);
-  old_registration_by_pattern = NULL;
+  old_registration_by_pattern = nullptr;
 
   scoped_refptr<ServiceWorkerRegistration> new_registration =
       RunRegisterJob(pattern,
                      GURL("http://www.example.com/service_worker_new.js"));
 
   ASSERT_EQ(old_registration, new_registration);
 
   scoped_refptr<ServiceWorkerRegistration> new_registration_by_pattern =
       FindRegistrationForPattern(pattern);
 
@@ skipping 47 matching lines @@
 };
 
 TEST_F(ServiceWorkerJobTest, Register_FailToStartWorker) {
   helper_.reset(new FailToStartWorkerTestHelper);
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       RunRegisterJob(GURL("http://www.example.com/"),
                      GURL("http://www.example.com/service_worker.js"),
                      SERVICE_WORKER_ERROR_START_WORKER_FAILED);
 
-  ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
+  ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(nullptr), registration);
 }
 
 // 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), nullptr,
       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), 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(
-      pattern,
-      script_url2,
-      NULL,
-      SaveRegistration(
-          SERVICE_WORKER_OK, &registration2_called, &registration2));
+      script_url2, ServiceWorkerRegistrationOptions(pattern), 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 =
       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), nullptr,
+      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), 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);
 
   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), nullptr,
+      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), nullptr,
+      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), nullptr,
+      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)), nullptr,
         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 402 matching lines @@
   // Update should abort after it starts and sees uninstalling.
   job_coordinator()->Update(registration.get(), false);
 
   EXPECT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
   // Verify the registration was not modified by the Update.
   EXPECT_TRUE(registration->is_uninstalling());
   EXPECT_EQ(active_version, registration->active_version());
-  EXPECT_EQ(NULL, registration->waiting_version());
-  EXPECT_EQ(NULL, registration->installing_version());
+  EXPECT_EQ(nullptr, registration->waiting_version());
+  EXPECT_EQ(nullptr, registration->installing_version());
 }
 
 TEST_F(ServiceWorkerJobTest, RegisterWhileUninstalling) {
   GURL pattern("http://www.example.com/one/");
   GURL script1("http://www.example.com/service_worker.js");
   GURL script2("http://www.example.com/service_worker.js?new");
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       RunRegisterJob(pattern, script1);
   scoped_refptr<base::TestSimpleTaskRunner> runner(
@@ skipping 10 matching lines @@
   // Register another script.
   EXPECT_EQ(registration, RunRegisterJob(pattern, script2));
 
   EXPECT_FALSE(registration->is_uninstalling());
   EXPECT_EQ(old_version, registration->active_version());
 
   scoped_refptr<ServiceWorkerVersion> new_version =
       registration->waiting_version();
 
   // Verify the new version is installed but not activated yet.
-  EXPECT_EQ(NULL, registration->installing_version());
+  EXPECT_EQ(nullptr, registration->installing_version());
   EXPECT_TRUE(new_version);
   EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, new_version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::INSTALLED, new_version->status());
 
   old_version->RemoveControllee(host.get());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(registration->is_uninstalling());
   EXPECT_FALSE(registration->is_uninstalled());
 
   // Verify the new version is activated.
-  EXPECT_EQ(NULL, registration->installing_version());
-  EXPECT_EQ(NULL, registration->waiting_version());
+  EXPECT_EQ(nullptr, registration->installing_version());
+  EXPECT_EQ(nullptr, registration->waiting_version());
   EXPECT_EQ(new_version, registration->active_version());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATING, new_version->status());
 
   runner->RunUntilIdle();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, new_version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, new_version->status());
 }
 
 TEST_F(ServiceWorkerJobTest, RegisterAndUnregisterWhileUninstalling) {
@@ skipping 77 matching lines @@
   EXPECT_FALSE(registration->is_uninstalling());
   EXPECT_EQ(new_version, registration->waiting_version());
 
   old_version->RemoveControllee(host.get());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(registration->is_uninstalling());
   EXPECT_FALSE(registration->is_uninstalled());
 
   // Verify the new version is activated.
-  EXPECT_EQ(NULL, registration->installing_version());
-  EXPECT_EQ(NULL, registration->waiting_version());
+  EXPECT_EQ(nullptr, registration->installing_version());
+  EXPECT_EQ(nullptr, registration->waiting_version());
   EXPECT_EQ(new_version, registration->active_version());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATING, new_version->status());
 
   runner->RunUntilIdle();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, new_version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, new_version->status());
 }
 
 TEST_F(ServiceWorkerJobTest, RegisterMultipleTimesWhileUninstalling) {
@@ skipping 34 matching lines @@
   EXPECT_FALSE(registration->is_uninstalling());
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, second_version->status());
 
   first_version->RemoveControllee(host.get());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(registration->is_uninstalling());
   EXPECT_FALSE(registration->is_uninstalled());
 
   // Verify the new version is activated.
-  EXPECT_EQ(NULL, registration->installing_version());
-  EXPECT_EQ(NULL, registration->waiting_version());
+  EXPECT_EQ(nullptr, registration->installing_version());
+  EXPECT_EQ(nullptr, registration->waiting_version());
   EXPECT_EQ(third_version, registration->active_version());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATING, third_version->status());
 
   runner->RunUntilIdle();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, third_version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, third_version->status());
 }
 
 class EventCallbackHelper : public EmbeddedWorkerTestHelper {
@@ skipping 64 matching lines @@
                  old_version, host.get()));
   EXPECT_EQ(registration, RunRegisterJob(pattern, script2));
 
   EXPECT_FALSE(registration->is_uninstalling());
   EXPECT_FALSE(registration->is_uninstalled());
 
   // Verify the new version is activated.
   scoped_refptr<ServiceWorkerVersion> new_version =
       registration->active_version();
   EXPECT_NE(old_version, new_version);
-  EXPECT_EQ(NULL, registration->installing_version());
-  EXPECT_EQ(NULL, registration->waiting_version());
+  EXPECT_EQ(nullptr, registration->installing_version());
+  EXPECT_EQ(nullptr, registration->waiting_version());
   EXPECT_EQ(new_version, registration->active_version());
   EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, new_version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, new_version->status());
 
   EXPECT_EQ(registration, FindRegistrationForPattern(pattern));
 }
 
 TEST_F(ServiceWorkerJobTest, RemoveControlleeDuringRejectedInstall) {
   EventCallbackHelper* helper = new EventCallbackHelper;
   helper_.reset(helper);
@@ skipping 196 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