Add helper methods to ServiceWorkerJobTest

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 "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
@@ skipping 100 matching lines @@
   void TearDown() override { helper_.reset(); }
 
   ServiceWorkerContextCore* context() const { return helper_->context(); }
 
   ServiceWorkerJobCoordinator* job_coordinator() const {
     return context()->job_coordinator();
   }
   ServiceWorkerStorage* storage() const { return context()->storage(); }
 
  protected:
+  scoped_refptr<ServiceWorkerRegistration> RunRegisterJob(
+      const GURL& pattern,
+      const GURL& script_url,
+      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);
+
   TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
   int render_process_id_;
 };
 
-TEST_F(ServiceWorkerJobTest, SameDocumentSameRegistration) {
-  scoped_refptr<ServiceWorkerRegistration> original_registration;
+scoped_refptr<ServiceWorkerRegistration> ServiceWorkerJobTest::RunRegisterJob(
+    const GURL& pattern,
+    const GURL& script_url,
+    ServiceWorkerStatusCode expected_status) {
+  scoped_refptr<ServiceWorkerRegistration> registration;
   bool called;
   job_coordinator()->Register(
-      GURL("http://www.example.com/"),
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &original_registration));
+      pattern, script_url, 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) {
+  bool called;
+  job_coordinator()->Unregister(pattern,
+                                SaveUnregistration(expected_status, &called));
+  EXPECT_FALSE(called);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(called);
+}
+
+scoped_refptr<ServiceWorkerRegistration>
+ServiceWorkerJobTest::FindRegistrationForPattern(
+    const GURL& pattern,
+    ServiceWorkerStatusCode expected_status) {
+  bool called;
+  scoped_refptr<ServiceWorkerRegistration> registration;
+  storage()->FindRegistrationForPattern(
+      pattern,
+      SaveFoundRegistration(expected_status, &called, &registration));
+
+  EXPECT_FALSE(called);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(called);
+  return registration;
+}
+
+TEST_F(ServiceWorkerJobTest, SameDocumentSameRegistration) {
+  scoped_refptr<ServiceWorkerRegistration> original_registration =
+      RunRegisterJob(GURL("http://www.example.com/"),
+                     GURL("http://www.example.com/service_worker.js"));
+  bool called;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   storage()->FindRegistrationForDocument(
       GURL("http://www.example.com/"),
       SaveFoundRegistration(SERVICE_WORKER_OK, &called, &registration1));
   scoped_refptr<ServiceWorkerRegistration> registration2;
   storage()->FindRegistrationForDocument(
       GURL("http://www.example.com/"),
       SaveFoundRegistration(SERVICE_WORKER_OK, &called, &registration2));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   ASSERT_TRUE(registration1.get());
   ASSERT_EQ(registration1, original_registration);
   ASSERT_EQ(registration1, registration2);
 }
 
 TEST_F(ServiceWorkerJobTest, SameMatchSameRegistration) {
   bool called;
-  scoped_refptr<ServiceWorkerRegistration> original_registration;
-  job_coordinator()->Register(
-      GURL("http://www.example.com/"),
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &original_registration));
-  EXPECT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(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),
             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);
 
@@ skipping 40 matching lines @@
       SaveFoundRegistration(SERVICE_WORKER_OK, &called2, &registration2));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called2);
   EXPECT_TRUE(called1);
   ASSERT_NE(registration1, registration2);
 }
 
 // Make sure basic registration is working.
 TEST_F(ServiceWorkerJobTest, Register) {
-  bool called = false;
-  scoped_refptr<ServiceWorkerRegistration> registration;
-  job_coordinator()->Register(
-      GURL("http://www.example.com/"),
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
-
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  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);
 }
 
 // Make sure registrations are cleaned up when they are unregistered.
 TEST_F(ServiceWorkerJobTest, Unregister) {
   GURL pattern("http://www.example.com/");
 
-  bool called;
-  scoped_refptr<ServiceWorkerRegistration> registration;
-  job_coordinator()->Register(
-      pattern,
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
+  scoped_refptr<ServiceWorkerRegistration> registration =
+      RunRegisterJob(pattern, GURL("http://www.example.com/service_worker.js"));
 
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
-
-  job_coordinator()->Unregister(pattern,
-                                SaveUnregistration(SERVICE_WORKER_OK, &called));
-
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  RunUnregisterJob(pattern);
 
   ASSERT_TRUE(registration->HasOneRef());
 
-  storage()->FindRegistrationForPattern(
-      pattern,
-      SaveFoundRegistration(SERVICE_WORKER_ERROR_NOT_FOUND,
-                            &called, &registration));
-
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  registration = FindRegistrationForPattern(pattern,
+                                            SERVICE_WORKER_ERROR_NOT_FOUND);
 
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
 }
 
 TEST_F(ServiceWorkerJobTest, Unregister_NothingRegistered) {
   GURL pattern("http://www.example.com/");
 
-  bool called;
-  job_coordinator()->Unregister(
-      pattern,
-      SaveUnregistration(SERVICE_WORKER_ERROR_NOT_FOUND, &called));
-
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  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/");
 
-  bool called;
-  scoped_refptr<ServiceWorkerRegistration> old_registration;
-  job_coordinator()->Register(
-      pattern,
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &old_registration));
+  scoped_refptr<ServiceWorkerRegistration> old_registration =
+      RunRegisterJob(pattern, GURL("http://www.example.com/service_worker.js"));
 
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
-
-  scoped_refptr<ServiceWorkerRegistration> old_registration_by_pattern;
-  storage()->FindRegistrationForPattern(
-      pattern,
-      SaveFoundRegistration(
-          SERVICE_WORKER_OK, &called, &old_registration_by_pattern));
-
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  scoped_refptr<ServiceWorkerRegistration> old_registration_by_pattern =
+      FindRegistrationForPattern(pattern);
 
   ASSERT_EQ(old_registration, old_registration_by_pattern);
   old_registration_by_pattern = NULL;
 
-  scoped_refptr<ServiceWorkerRegistration> new_registration;
-  job_coordinator()->Register(
-      pattern,
-      GURL("http://www.example.com/service_worker_new.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &new_registration));
-
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  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;
-  storage()->FindRegistrationForPattern(
-      pattern,
-      SaveFoundRegistration(
-          SERVICE_WORKER_OK, &called, &new_registration));

[Kunihiko Sakamoto, 2015/02/02 11:01:32]

I think there was a bug here; |new_registration| should be
|new_registration_by_pattern|.

+  scoped_refptr<ServiceWorkerRegistration> new_registration_by_pattern =
+      FindRegistrationForPattern(pattern);
 
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
-
-  ASSERT_NE(new_registration_by_pattern, old_registration);
+  ASSERT_EQ(new_registration, new_registration_by_pattern);
 }
 
 // Make sure that when registering a duplicate pattern+script_url
 // combination, that the same registration is used.
 TEST_F(ServiceWorkerJobTest, RegisterDuplicateScript) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
-  bool called;
-  scoped_refptr<ServiceWorkerRegistration> old_registration;
-  job_coordinator()->Register(
-      pattern,
-      script_url,
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &old_registration));
+  scoped_refptr<ServiceWorkerRegistration> old_registration =
+      RunRegisterJob(pattern, script_url);
 
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
-
-  scoped_refptr<ServiceWorkerRegistration> old_registration_by_pattern;
-  storage()->FindRegistrationForPattern(
-      pattern,
-      SaveFoundRegistration(
-          SERVICE_WORKER_OK, &called, &old_registration_by_pattern));
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  scoped_refptr<ServiceWorkerRegistration> old_registration_by_pattern =
+      FindRegistrationForPattern(pattern);
 
   ASSERT_TRUE(old_registration_by_pattern.get());
 
-  scoped_refptr<ServiceWorkerRegistration> new_registration;
-  job_coordinator()->Register(
-      pattern,
-      script_url,
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &new_registration));
-
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  scoped_refptr<ServiceWorkerRegistration> new_registration =
+      RunRegisterJob(pattern, script_url);
 
   ASSERT_EQ(old_registration, new_registration);
 
   ASSERT_FALSE(old_registration->HasOneRef());
 
-  scoped_refptr<ServiceWorkerRegistration> new_registration_by_pattern;
-  storage()->FindRegistrationForPattern(
-      pattern,
-      SaveFoundRegistration(
-          SERVICE_WORKER_OK, &called, &new_registration_by_pattern));
-
-  ASSERT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  scoped_refptr<ServiceWorkerRegistration> new_registration_by_pattern =
+      FindRegistrationForPattern(pattern);
 
   ASSERT_EQ(new_registration, old_registration);
 }
 
 class FailToStartWorkerTestHelper : public EmbeddedWorkerTestHelper {
  public:
   explicit FailToStartWorkerTestHelper(int mock_render_process_id)
       : EmbeddedWorkerTestHelper(mock_render_process_id) {}
 
   void OnStartWorker(int embedded_worker_id,
                      int64 service_worker_version_id,
                      const GURL& scope,
                      const GURL& script_url,
                      bool pause_after_download) override {
     EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
     registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id);
   }
 };
 
 TEST_F(ServiceWorkerJobTest, Register_FailToStartWorker) {
   helper_.reset(new FailToStartWorkerTestHelper(render_process_id_));
 
-  bool called = false;
-  scoped_refptr<ServiceWorkerRegistration> registration;
-  job_coordinator()->Register(
-      GURL("http://www.example.com/"),
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(
-          SERVICE_WORKER_ERROR_START_WORKER_FAILED, &called, &registration));
+  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_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-
-  ASSERT_TRUE(called);
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(NULL), 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,
       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);
 
-  bool find_called = false;
-  storage()->FindRegistrationForPattern(
-      pattern,
-      SaveFoundRegistration(
-          SERVICE_WORKER_ERROR_NOT_FOUND, &find_called, &registration));
-
-  base::RunLoop().RunUntilIdle();
+  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/");
 
@@ skipping 16 matching lines @@
       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;
-  bool find_called = false;
-  storage()->FindRegistrationForPattern(
-      pattern,
-      SaveFoundRegistration(
-          SERVICE_WORKER_OK, &find_called, &registration));
-
-  base::RunLoop().RunUntilIdle();
+  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/");
 
@@ skipping 17 matching lines @@
           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;
-  bool find_called = false;
-  storage()->FindRegistrationForPattern(
-      pattern,
-      SaveFoundRegistration(
-          SERVICE_WORKER_OK, &find_called, &registration));
+  scoped_refptr<ServiceWorkerRegistration> registration =
+      FindRegistrationForPattern(pattern);
 
-  base::RunLoop().RunUntilIdle();
   ASSERT_EQ(registration, registration1);
 }
 
 // Call simulataneous unregister calls.
 TEST_F(ServiceWorkerJobTest, ParallelUnreg) {
   GURL pattern("http://www.example.com/");
 
   GURL script_url("http://www.example.com/service_worker.js");
   bool unregistration1_called = false;
   job_coordinator()->Unregister(
       pattern,
       SaveUnregistration(SERVICE_WORKER_ERROR_NOT_FOUND,
                          &unregistration1_called));
 
   bool unregistration2_called = false;
   job_coordinator()->Unregister(
       pattern,
       SaveUnregistration(SERVICE_WORKER_ERROR_NOT_FOUND,
                          &unregistration2_called));
 
   ASSERT_FALSE(unregistration1_called);
   ASSERT_FALSE(unregistration2_called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(unregistration1_called);
   ASSERT_TRUE(unregistration2_called);
 
   // There isn't really a way to test that they are being coalesced,
   // but we can make sure they can exist simultaneously without
   // crashing.
-  scoped_refptr<ServiceWorkerRegistration> registration;
-  bool find_called = false;
-  storage()->FindRegistrationForPattern(
-      pattern,
-      SaveFoundRegistration(
-          SERVICE_WORKER_ERROR_NOT_FOUND, &find_called, &registration));
+  scoped_refptr<ServiceWorkerRegistration> registration =
+      FindRegistrationForPattern(pattern, SERVICE_WORKER_ERROR_NOT_FOUND);
 
-  base::RunLoop().RunUntilIdle();
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 }
 
 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;
@@ skipping 87 matching lines @@
                          &unregistration_called));
 
   ASSERT_FALSE(registration_called);
   ASSERT_FALSE(unregistration_called);
   job_coordinator()->AbortAll();
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(registration_called);
   ASSERT_TRUE(unregistration_called);
 
-  bool find_called = false;
-  storage()->FindRegistrationForPattern(
-      pattern,
-      SaveFoundRegistration(
-          SERVICE_WORKER_ERROR_NOT_FOUND, &find_called, &registration));
+  registration = FindRegistrationForPattern(pattern,
+                                            SERVICE_WORKER_ERROR_NOT_FOUND);
 
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(find_called);
   EXPECT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 }
 
 // Tests that the waiting worker enters the 'redundant' state upon
 // unregistration.
 TEST_F(ServiceWorkerJobTest, UnregisterWaitingSetsRedundant) {
-  scoped_refptr<ServiceWorkerRegistration> registration;
-  bool called = false;
   GURL script_url("http://www.example.com/service_worker.js");
-  job_coordinator()->Register(
-      GURL("http://www.example.com/"),
-      script_url,
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  scoped_refptr<ServiceWorkerRegistration> registration =
+      RunRegisterJob(GURL("http://www.example.com/"), script_url);
   ASSERT_TRUE(registration.get());
 
   // Manually create the waiting worker since there is no way to become a
   // waiting worker until Update is implemented.
   scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion(
       registration.get(), script_url, 1L, helper_->context()->AsWeakPtr());
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
   version->StartWorker(CreateReceiverOnCurrentThread(&status));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(SERVICE_WORKER_OK, status);
 
   version->SetStatus(ServiceWorkerVersion::INSTALLED);
   registration->SetWaitingVersion(version.get());
   EXPECT_EQ(ServiceWorkerVersion::RUNNING,
             version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::INSTALLED, version->status());
 
-  called = false;
-  job_coordinator()->Unregister(GURL("http://www.example.com/"),
-                                SaveUnregistration(SERVICE_WORKER_OK, &called));
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  RunUnregisterJob(GURL("http://www.example.com/"));
 
   // The version should be stopped since there is no controllee after
   // unregistration.
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version->status());
 }
 
 // Tests that the active worker enters the 'redundant' state upon
 // unregistration.
 TEST_F(ServiceWorkerJobTest, UnregisterActiveSetsRedundant) {
-  scoped_refptr<ServiceWorkerRegistration> registration;
-  bool called = false;
-  job_coordinator()->Register(
-      GURL("http://www.example.com/"),
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  scoped_refptr<ServiceWorkerRegistration> registration =
+      RunRegisterJob(GURL("http://www.example.com/"),
+                     GURL("http://www.example.com/service_worker.js"));
   ASSERT_TRUE(registration.get());
 
   scoped_refptr<ServiceWorkerVersion> version = registration->active_version();
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, version->status());
 
-  called = false;
-  job_coordinator()->Unregister(GURL("http://www.example.com/"),
-                                SaveUnregistration(SERVICE_WORKER_OK, &called));
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  RunUnregisterJob(GURL("http://www.example.com/"));
 
   // The version should be stopped since there is no controllee after
   // unregistration.
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version->status());
 }
 
 // Tests that the active worker enters the 'redundant' state upon
 // unregistration.
 TEST_F(ServiceWorkerJobTest,
        UnregisterActiveSetsRedundant_WaitForNoControllee) {
-  scoped_refptr<ServiceWorkerRegistration> registration;
-  bool called = false;
-  job_coordinator()->Register(
-      GURL("http://www.example.com/"),
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  scoped_refptr<ServiceWorkerRegistration> registration =
+      RunRegisterJob(GURL("http://www.example.com/"),
+                     GURL("http://www.example.com/service_worker.js"));
   ASSERT_TRUE(registration.get());
 
   scoped_ptr<ServiceWorkerProviderHost> host(
       new ServiceWorkerProviderHost(33 /* dummy render process id */,
                                     MSG_ROUTING_NONE /* render_frame_id */,
                                     1 /* dummy provider_id */,
                                     context()->AsWeakPtr(),
                                     NULL));
   registration->active_version()->AddControllee(host.get());
 
   scoped_refptr<ServiceWorkerVersion> version = registration->active_version();
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, version->status());
 
-  called = false;
-  job_coordinator()->Unregister(GURL("http://www.example.com/"),
-                                SaveUnregistration(SERVICE_WORKER_OK, &called));
-  base::RunLoop().RunUntilIdle();
-  ASSERT_TRUE(called);
+  RunUnregisterJob(GURL("http://www.example.com/"));
 
   // The version should be running since there is still a controllee.
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, version->status());
 
   registration->active_version()->RemoveControllee(host.get());
   base::RunLoop().RunUntilIdle();
 
   // The version should be stopped since there is no controllee.
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version->running_status());
@@ skipping 302 matching lines @@
 
   EXPECT_EQ(registration->active_version()->version_id(),
             update_helper->state_change_log_[4].version_id);
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED,
             update_helper->state_change_log_[4].status);
 
   EXPECT_TRUE(update_helper->update_found_);
 }
 
 TEST_F(ServiceWorkerJobTest, Update_NewestVersionChanged) {
-  bool called;
-  scoped_refptr<ServiceWorkerRegistration> registration;
-  job_coordinator()->Register(
-      GURL("http://www.example.com/one/"),
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
+  scoped_refptr<ServiceWorkerRegistration> registration =
+      RunRegisterJob(GURL("http://www.example.com/one/"),
+                     GURL("http://www.example.com/service_worker.js"));
 
-  EXPECT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(called);
   ServiceWorkerVersion* active_version = registration->active_version();
 
   // Queue an Update, it should abort when it starts and sees the new version.
   job_coordinator()->Update(registration.get());
 
   // Add a waiting version with new script.
   scoped_refptr<ServiceWorkerVersion> version =
       new ServiceWorkerVersion(registration.get(),
                                GURL("http://www.example.com/new_worker.js"),
                                2L /* dummy version id */,
                                helper_->context()->AsWeakPtr());
   registration->SetWaitingVersion(version.get());
 
   base::RunLoop().RunUntilIdle();
 
   // Verify the registration was not modified by the Update.
   EXPECT_EQ(active_version, registration->active_version());
   EXPECT_EQ(version.get(), registration->waiting_version());
   EXPECT_EQ(NULL, registration->installing_version());
 }
 
 TEST_F(ServiceWorkerJobTest, Update_UninstallingRegistration) {
   bool called;
-  scoped_refptr<ServiceWorkerRegistration> registration;
-  job_coordinator()->Register(
-      GURL("http://www.example.com/one/"),
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
-
-  EXPECT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(called);
+  scoped_refptr<ServiceWorkerRegistration> registration =
+      RunRegisterJob(GURL("http://www.example.com/one/"),
+                     GURL("http://www.example.com/service_worker.js"));
 
   // Add a controllee and queue an unregister to force the uninstalling state.
   scoped_ptr<ServiceWorkerProviderHost> host(
       new ServiceWorkerProviderHost(33 /* dummy render_process id */,
                                     MSG_ROUTING_NONE /* render_frame_id */,
                                     1 /* dummy provider_id */,
                                     helper_->context()->AsWeakPtr(),
                                     NULL));
   ServiceWorkerVersion* active_version = registration->active_version();
   active_version->AddControllee(host.get());
   job_coordinator()->Unregister(GURL("http://www.example.com/one/"),
                                 SaveUnregistration(SERVICE_WORKER_OK, &called));
 
   // Update should abort after it starts and sees uninstalling.
   job_coordinator()->Update(registration.get());
 
   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());
 }
 
 }  // namespace content