Add ServiceWorkerVersion::status() (which is to be persisted unlike running status)

content/browser/service_worker/service_worker_version.cc

Index: content/browser/service_worker/service_worker_version.cc
diff --git a/content/browser/service_worker/service_worker_version.cc b/content/browser/service_worker/service_worker_version.cc
index c4cd44b6d71205ca68628a8e775e06874f08507a..db9e9ba6f65308ebcf0261448ca4d23748768e37 100644
--- a/content/browser/service_worker/service_worker_version.cc
+++ b/content/browser/service_worker/service_worker_version.cc
@@ -41,7 +41,7 @@ void RunTaskAfterStartWorker(
       error_callback.Run(status);
     return;
   }
-  if (version->status() != ServiceWorkerVersion::RUNNING) {
+  if (version->running_status() != ServiceWorkerVersion::RUNNING) {
     // We've tried to start the worker (and it has succeeded), but
     // it looks it's not running yet.
     NOTREACHED() << "The worker's not running after successful StartWorker";
@@ -95,6 +95,7 @@ ServiceWorkerVersion::ServiceWorkerVersion(
     EmbeddedWorkerRegistry* worker_registry,
     int64 version_id)
     : version_id_(version_id),
+      status_(NEW),
       is_shutdown_(false),
       registration_(registration),
       weak_factory_(this) {
@@ -119,11 +120,11 @@ void ServiceWorkerVersion::StartWorker(const StatusCallback& callback) {
   DCHECK(!is_shutdown_);
   DCHECK(embedded_worker_);
   DCHECK(registration_);
-  if (status() == RUNNING) {
+  if (running_status() == RUNNING) {
     RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
     return;
   }
-  if (status() == STOPPING) {
+  if (running_status() == STOPPING) {
     RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_START_WORKER_FAILED));
     return;
   }
@@ -142,7 +143,7 @@ void ServiceWorkerVersion::StartWorker(const StatusCallback& callback) {
 void ServiceWorkerVersion::StopWorker(const StatusCallback& callback) {
   DCHECK(!is_shutdown_);
   DCHECK(embedded_worker_);
-  if (status() == STOPPED) {
+  if (running_status() == STOPPED) {
     RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
     return;
   }
@@ -160,7 +161,7 @@ void ServiceWorkerVersion::SendMessage(
     const IPC::Message& message, const StatusCallback& callback) {
   DCHECK(!is_shutdown_);
   DCHECK(embedded_worker_);
-  if (status() != RUNNING) {
+  if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
                            weak_factory_.GetWeakPtr(), callback,
@@ -179,7 +180,7 @@ void ServiceWorkerVersion::SendMessageAndRegisterCallback(
     const IPC::Message& message, const MessageCallback& callback) {
   DCHECK(!is_shutdown_);
   DCHECK(embedded_worker_);
-  if (status() != RUNNING) {
+  if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
                            weak_factory_.GetWeakPtr(),
@@ -203,6 +204,12 @@ void ServiceWorkerVersion::SendMessageAndRegisterCallback(
 void ServiceWorkerVersion::DispatchInstallEvent(
     int active_version_embedded_worker_id,
     const StatusCallback& callback) {
+  if (status() != NEW) {

[michaeln, 2014/03/10 18:53:45]

I wonder if we should [D]CHECK these instead of having a branch for it?

[kinuko, 2014/03/11 06:58:34]

Let me land this as is (branch + NOTREACHED) for now, I'm not really determined 
how to handle error cases for these yet.

+    // Unexpected.
+    NOTREACHED();
+    RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
+    return;
+  }
   SendMessageAndRegisterCallback(
       ServiceWorkerMsg_InstallEvent(active_version_embedded_worker_id),
       base::Bind(&HandleInstallFinished, callback));
@@ -211,6 +218,13 @@ void ServiceWorkerVersion::DispatchInstallEvent(
 void ServiceWorkerVersion::DispatchFetchEvent(
     const ServiceWorkerFetchRequest& request,
     const FetchCallback& callback) {
+  if (status() != ACTIVE) {
+    // Unexpected.
+    NOTREACHED();
+    RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_FAILED,
+                       ServiceWorkerFetchResponse()));
+    return;
+  }
   SendMessageAndRegisterCallback(
       ServiceWorkerMsg_FetchEvent(request),
       base::Bind(&HandleFetchResponse, callback));
@@ -226,14 +240,14 @@ void ServiceWorkerVersion::RemoveProcessToWorker(int process_id) {
 }
 
 void ServiceWorkerVersion::OnStarted() {
-  DCHECK_EQ(RUNNING, status());
+  DCHECK_EQ(RUNNING, running_status());
   // Fire all start callbacks.
   RunCallbacks(start_callbacks_, SERVICE_WORKER_OK);
   start_callbacks_.clear();
 }
 
 void ServiceWorkerVersion::OnStopped() {
-  DCHECK_EQ(STOPPED, status());
+  DCHECK_EQ(STOPPED, running_status());
   // Fire all stop callbacks.
   RunCallbacks(stop_callbacks_, SERVICE_WORKER_OK);
   stop_callbacks_.clear();