Service Worker: Unregister sets waiting worker's state to 'redundant'

As per spec's [[Unregister]] algorithm.

BUG=388095,371671

Review URL: https://codereview.chromium.org/349403002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@279637 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 79 insertions, 26 deletions

diff --git a/content/browser/service_worker/service_worker_handle.cc b/content/browser/service_worker/service_worker_handle.cc
index a07ab9e..3f4e1c0 100644
--- a/content/browser/service_worker/service_worker_handle.cc
+++ b/content/browser/service_worker/service_worker_handle.cc
@@ -30,7 +30,7 @@ GetWebServiceWorkerState(ServiceWorkerVersion* version) {
       return blink::WebServiceWorkerStateActivating;
     case ServiceWorkerVersion::ACTIVE:
       return blink::WebServiceWorkerStateActive;
-    case ServiceWorkerVersion::DEACTIVATED:
+    case ServiceWorkerVersion::REDUNDANT:
       return blink::WebServiceWorkerStateDeactivated;
   }
   NOTREACHED() << version->status();
diff --git a/content/browser/service_worker/service_worker_internals_ui.cc b/content/browser/service_worker/service_worker_internals_ui.cc
index e976ad8..ffcb1b0 100644
--- a/content/browser/service_worker/service_worker_internals_ui.cc
+++ b/content/browser/service_worker/service_worker_internals_ui.cc
@@ -192,8 +192,8 @@ void UpdateVersionInfo(const ServiceWorkerVersionInfo& version,
     case ServiceWorkerVersion::ACTIVE:
       info->SetString("status", "ACTIVE");
       break;
-    case ServiceWorkerVersion::DEACTIVATED:
-      info->SetString("status", "DEACTIVATED");
+    case ServiceWorkerVersion::REDUNDANT:
+      info->SetString("status", "REDUNDANT");
       break;
   }
   info->SetString("version_id", base::Int64ToString(version.version_id));
diff --git a/content/browser/service_worker/service_worker_job_unittest.cc b/content/browser/service_worker/service_worker_job_unittest.cc
index efa8bd1..9c0cfc0 100644
--- a/content/browser/service_worker/service_worker_job_unittest.cc
+++ b/content/browser/service_worker/service_worker_job_unittest.cc
@@ -12,6 +12,7 @@
 #include "content/browser/service_worker/service_worker_job_coordinator.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_registration_status.h"
+#include "content/browser/service_worker/service_worker_test_utils.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "ipc/ipc_test_sink.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -699,4 +700,44 @@ TEST_F(ServiceWorkerJobTest, AbortAll_RegUnreg) {
   EXPECT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 }
 
+// Tests that the waiting worker enters the 'redundant' state upon
+// unregistration.
+TEST_F(ServiceWorkerJobTest, UnregisterSetsRedundant) {
+  scoped_refptr<ServiceWorkerRegistration> registration;
+  bool called = false;
+  job_coordinator()->Register(
+      GURL("http://www.example.com/*"),
+      GURL("http://www.example.com/service_worker.js"),
+      render_process_id_,
+      SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
+  base::RunLoop().RunUntilIdle();
+  ASSERT_TRUE(called);
+  ASSERT_TRUE(registration);
+
+  // 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, 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->set_waiting_version(version);
+  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);
+
+  EXPECT_EQ(ServiceWorkerVersion::RUNNING,
+            version->running_status());
+  EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version->status());
+}
+
 }  // namespace content
diff --git a/content/browser/service_worker/service_worker_registration.cc b/content/browser/service_worker/service_worker_registration.cc
index 9e166b6..7ea5029 100644
--- a/content/browser/service_worker/service_worker_registration.cc
+++ b/content/browser/service_worker/service_worker_registration.cc
@@ -49,7 +49,7 @@ ServiceWorkerVersion* ServiceWorkerRegistration::GetNewestVersion() {
 }
 
 void ServiceWorkerRegistration::ActivateWaitingVersion() {
-  active_version_->SetStatus(ServiceWorkerVersion::DEACTIVATED);
+  active_version_->SetStatus(ServiceWorkerVersion::REDUNDANT);
   active_version_ = waiting_version_;
   // TODO(kinuko): This should be set to ACTIVATING until activation finishes.
   active_version_->SetStatus(ServiceWorkerVersion::ACTIVE);
diff --git a/content/browser/service_worker/service_worker_unregister_job.cc b/content/browser/service_worker/service_worker_unregister_job.cc
index dabcd22..48f51ee 100644
--- a/content/browser/service_worker/service_worker_unregister_job.cc
+++ b/content/browser/service_worker/service_worker_unregister_job.cc
@@ -30,7 +30,7 @@ void ServiceWorkerUnregisterJob::AddCallback(
 void ServiceWorkerUnregisterJob::Start() {
   context_->storage()->FindRegistrationForPattern(
       pattern_,
-      base::Bind(&ServiceWorkerUnregisterJob::DeleteExistingRegistration,
+      base::Bind(&ServiceWorkerUnregisterJob::OnRegistrationFound,
                  weak_factory_.GetWeakPtr()));
 }
 
@@ -48,29 +48,41 @@ RegistrationJobType ServiceWorkerUnregisterJob::GetType() {
   return ServiceWorkerRegisterJobBase::UNREGISTRATION;
 }
 
-void ServiceWorkerUnregisterJob::DeleteExistingRegistration(
+void ServiceWorkerUnregisterJob::OnRegistrationFound(
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
-  if (status == SERVICE_WORKER_OK) {
-    DCHECK(registration);
-    // TODO(michaeln): Deactivate the live registration object and
-    // eventually call storage->DeleteVersionResources()
-    // when the version no longer has any controllees.
-    context_->storage()->DeleteRegistration(
-        registration->id(),
-        registration->script_url().GetOrigin(),
-        base::Bind(&ServiceWorkerUnregisterJob::Complete,
-                   weak_factory_.GetWeakPtr()));
-    return;
-  }
-
   if (status == SERVICE_WORKER_ERROR_NOT_FOUND) {
     DCHECK(!registration);
     Complete(SERVICE_WORKER_OK);
     return;
   }
 
-  Complete(status);
+  if (status != SERVICE_WORKER_OK) {
+    Complete(status);
+    return;
+  }
+
+  DCHECK(registration);
+  DeleteRegistration(registration);
+}
+
+void ServiceWorkerUnregisterJob::DeleteRegistration(
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  // TODO(nhiroki): When we've implemented the installing version, terminate and
+  // set it to redundant here as per spec.
+
+  if (registration->waiting_version()) {
+    registration->waiting_version()->SetStatus(
+        ServiceWorkerVersion::REDUNDANT);
+  }
+
+  // TODO(michaeln): Eventually call storage->DeleteVersionResources() when the
+  // version no longer has any controllees.
+  context_->storage()->DeleteRegistration(
+      registration->id(),
+      registration->script_url().GetOrigin(),
+      base::Bind(&ServiceWorkerUnregisterJob::Complete,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerUnregisterJob::Complete(ServiceWorkerStatusCode status) {
diff --git a/content/browser/service_worker/service_worker_unregister_job.h b/content/browser/service_worker/service_worker_unregister_job.h
index 4843181..0a1697a 100644
--- a/content/browser/service_worker/service_worker_unregister_job.h
+++ b/content/browser/service_worker/service_worker_unregister_job.h
@@ -45,13 +45,14 @@ class ServiceWorkerUnregisterJob : public ServiceWorkerRegisterJobBase {
   virtual RegistrationJobType GetType() OVERRIDE;
 
  private:
-  void DeleteExistingRegistration(
+  void OnRegistrationFound(
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
+  void DeleteRegistration(
+      const scoped_refptr<ServiceWorkerRegistration>& registration);
   void Complete(ServiceWorkerStatusCode status);
   void CompleteInternal(ServiceWorkerStatusCode status);
 
-  // The ServiceWorkerStorage object should always outlive this.
   base::WeakPtr<ServiceWorkerContextCore> context_;
   const GURL pattern_;
   std::vector<UnregistrationCallback> callbacks_;
diff --git a/content/browser/service_worker/service_worker_version.h b/content/browser/service_worker/service_worker_version.h
index bf54daf..f2fa341 100644
--- a/content/browser/service_worker/service_worker_version.h
+++ b/content/browser/service_worker/service_worker_version.h
@@ -68,9 +68,8 @@ class CONTENT_EXPORT ServiceWorkerVersion
     INSTALLED,   // Install event is finished and is ready to be activated.
     ACTIVATING,  // Activate event is dispatched and being handled.
     ACTIVE,      // Activation is finished and can run as active.
-    DEACTIVATED, // The version is no longer running as active, due to
-                 // unregistration or replace. (TODO(kinuko): we may need
-                 // different states for different termination sequences)
+    REDUNDANT,   // The version is no longer running as active, due to
+                 // unregistration or replace.
   };
 
   class Listener {
@@ -128,7 +127,7 @@ class CONTENT_EXPORT ServiceWorkerVersion
       bool pause_after_download,
       const StatusCallback& callback);
 
-  // Starts an embedded worker for this version.
+  // Stops an embedded worker for this version.
   // This returns OK (success) if the worker is already stopped.
   void StopWorker(const StatusCallback& callback);