ServiceWorker: SWRegisterJob should manage status of SWVersion

content/browser/service_worker/service_worker_version.cc

 // Copyright 2013 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 "content/browser/service_worker/service_worker_version.h"
 
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
@@ skipping 220 matching lines @@
     return;
   }
 
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(message);
   RunSoon(base::Bind(callback, status));
 }
 
 void ServiceWorkerVersion::DispatchInstallEvent(
     int active_version_id,
     const StatusCallback& callback) {
-  DCHECK_EQ(NEW, status()) << status();
+  DCHECK_EQ(INSTALLING, status()) << status();
 
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.

[nhiroki, 2014/07/07 08:26:41]

As I mentioned above, this code path will reach
ServiceWorkerContextRequestHandler::ShouldAddToScriptCache() with INSTALLING
status.

     StartWorker(
         base::Bind(&RunTaskAfterStartWorker,
                    weak_factory_.GetWeakPtr(),
                    callback,
                    base::Bind(&self::DispatchInstallEventAfterStartWorker,
                               weak_factory_.GetWeakPtr(),
                               active_version_id,
                               callback)));
   } else {
     DispatchInstallEventAfterStartWorker(active_version_id, callback);
   }
 }
 
 void ServiceWorkerVersion::DispatchActivateEvent(
     const StatusCallback& callback) {
-  DCHECK_EQ(INSTALLED, status()) << status();
-  SetStatus(ACTIVATING);
+  DCHECK_EQ(ACTIVATING, status()) << status();
 
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(
         base::Bind(&RunTaskAfterStartWorker,
                    weak_factory_.GetWeakPtr(),
                    callback,
                    base::Bind(&self::DispatchActivateEventAfterStartWorker,
                               weak_factory_.GetWeakPtr(),
                               callback)));
@@ skipping 234 matching lines @@
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK)
     RunCallbacks(this, &start_callbacks_, status);
 }
 
 void ServiceWorkerVersion::DispatchInstallEventAfterStartWorker(
     int active_version_id,
     const StatusCallback& callback) {
   DCHECK_EQ(RUNNING, running_status())
       << "Worker stopped too soon after it was started.";
-  SetStatus(INSTALLING);
 
   int request_id = install_callbacks_.Add(new StatusCallback(callback));
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_InstallEvent(request_id, active_version_id));
   if (status != SERVICE_WORKER_OK) {
     install_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
@@ skipping 21 matching lines @@
   // Don't bother if it's no longer running.
   if (running_status() == RUNNING) {
     embedded_worker_->SendMessage(
         ServiceWorkerMsg_DidGetClientDocuments(request_id, client_ids));
   }
 }
 
 void ServiceWorkerVersion::OnActivateEventFinished(
     int request_id,
     blink::WebServiceWorkerEventResult result) {
+  DCHECK_EQ(ACTIVATING, status()) << status();
+
   StatusCallback* callback = activate_callbacks_.Lookup(request_id);
   if (!callback) {
     NOTREACHED() << "Got unexpected message: " << request_id;
     return;
   }
   ServiceWorkerStatusCode status = SERVICE_WORKER_OK;
-  if (result == blink::WebServiceWorkerEventResultRejected) {
+  if (result == blink::WebServiceWorkerEventResultRejected)
     status = SERVICE_WORKER_ERROR_ACTIVATE_WORKER_FAILED;
-    SetStatus(REDUNDANT);
-  } else {
-    SetStatus(ACTIVE);
-  }
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
   callback->Run(status);
   activate_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerVersion::OnInstallEventFinished(
     int request_id,
     blink::WebServiceWorkerEventResult result) {
+  DCHECK_EQ(INSTALLING, status()) << status();
+
   StatusCallback* callback = install_callbacks_.Lookup(request_id);
   if (!callback) {
     NOTREACHED() << "Got unexpected message: " << request_id;
     return;
   }
   ServiceWorkerStatusCode status = SERVICE_WORKER_OK;
-  if (result == blink::WebServiceWorkerEventResultRejected) {
+  if (result == blink::WebServiceWorkerEventResultRejected)
     status = SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED;
-    SetStatus(REDUNDANT);
-  } else {
-    SetStatus(INSTALLED);
-  }
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
   callback->Run(status);
   install_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerVersion::OnFetchEventFinished(
     int request_id,
     ServiceWorkerFetchEventResult result,
     const ServiceWorkerResponse& response) {
@@ skipping 55 matching lines @@
     return;
   }
   stop_worker_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kStopWorkerDelay),
       base::Bind(&ServiceWorkerVersion::StopWorker,
                  weak_factory_.GetWeakPtr(),
                  base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)));
 }
 
 }  // namespace content