ServiceWorker: some more groundwork in support of the update process

content/browser/service_worker/service_worker_register_job.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_register_job.h"
 
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
@@ skipping 29 matching lines @@
 ServiceWorkerRegisterJob::~ServiceWorkerRegisterJob() {
   DCHECK(!context_ ||
          phase_ == INITIAL || phase_ == COMPLETE || phase_ == ABORT)
       << "Jobs should only be interrupted during shutdown.";
 }
 
 void ServiceWorkerRegisterJob::AddCallback(const RegistrationCallback& callback,
                                            int process_id) {
   if (!is_promise_resolved_) {
     callbacks_.push_back(callback);
-    if (process_id != -1 && (phase_ < UPDATE || !pending_version()))
+    if (process_id != -1 && (phase_ < UPDATE || !new_version()))
       pending_process_ids_.push_back(process_id);
     return;
   }
   RunSoon(base::Bind(
       callback, promise_resolved_status_,
       promise_resolved_registration_, promise_resolved_version_));
 }
 
 void ServiceWorkerRegisterJob::Start() {
   SetPhase(START);
@@ skipping 33 matching lines @@
   DCHECK(phase_ == START || phase_ == REGISTER) << phase_;
   DCHECK(!internal_.registration);
   internal_.registration = registration;
 }
 
 ServiceWorkerRegistration* ServiceWorkerRegisterJob::registration() {
   DCHECK(phase_ >= REGISTER) << phase_;
   return internal_.registration;
 }
 
-void ServiceWorkerRegisterJob::set_pending_version(
+void ServiceWorkerRegisterJob::set_new_version(
     ServiceWorkerVersion* version) {
   DCHECK(phase_ == UPDATE) << phase_;
-  DCHECK(!internal_.pending_version);
-  internal_.pending_version = version;
+  DCHECK(!internal_.new_version);
+  internal_.new_version = version;
 }
 
-ServiceWorkerVersion* ServiceWorkerRegisterJob::pending_version() {
+ServiceWorkerVersion* ServiceWorkerRegisterJob::new_version() {
   DCHECK(phase_ >= UPDATE) << phase_;
-  return internal_.pending_version;
+  return internal_.new_version;
 }
 
 void ServiceWorkerRegisterJob::SetPhase(Phase phase) {
   switch (phase) {
     case INITIAL:
       NOTREACHED();
       break;
     case START:
       DCHECK(phase_ == INITIAL) << phase_;
       break;
@@ skipping 99 matching lines @@
     // Abort this registration job.
     Complete(status);
     return;
   }
 
   // TODO(falken): "If serviceWorkerRegistration.installingWorker is not null.."
   // then terminate the installing worker. It doesn't make sense to implement
   // yet since we always activate the worker if install completed, so there can
   // be no installing worker at this point.
   // TODO(nhiroki): Check 'installing_version()' instead when it's supported.
   DCHECK(!registration()->waiting_version());

[nhiroki, 2014/07/02 07:25:12]

Can you check installing_version() instead of waiting_version()? (or just remove
this because we'll check it at line 267)

[michaeln, 2014/07/02 23:17:14]

Done.

 
   // "Let serviceWorker be a newly-created ServiceWorker object..." and start
   // the worker.
-  set_pending_version(new ServiceWorkerVersion(
+  set_new_version(new ServiceWorkerVersion(
       registration(), context_->storage()->NewVersionId(), context_));
 
   // TODO(michaeln): Pause after downloading when performing an update.
   bool pause_after_download = false;
   if (pause_after_download)
-    pending_version()->embedded_worker()->AddListener(this);
-  pending_version()->StartWorkerWithCandidateProcesses(
+    new_version()->embedded_worker()->AddListener(this);
+  new_version()->StartWorkerWithCandidateProcesses(
       pending_process_ids_,
       pause_after_download,
       base::Bind(&ServiceWorkerRegisterJob::OnStartWorkerFinished,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerRegisterJob::OnStartWorkerFinished(
     ServiceWorkerStatusCode status) {
   // "If serviceWorker fails to start up..." then reject the promise with an
   // error and abort.
   if (status != SERVICE_WORKER_OK) {
     Complete(status);
     return;
   }
 
+  // TODO(michaeln): Compare the old and new script.
+  // If different unpause the worker and continue with
+  // the job. If the same ResolvePromise with the current
+  // version and complete the job, throwing away the new version
+  // since there's nothing new.
+
   // "Resolve promise with serviceWorker."
-  // Although the spec doesn't set waitingWorker until after resolving the
-  // promise, our system's resolving works by passing ServiceWorkerRegistration
-  // to the callbacks, so waitingWorker must be set first.
-  DCHECK(!registration()->waiting_version());
-  registration()->set_waiting_version(pending_version());
-  ResolvePromise(status, registration(), pending_version());
-
-  AssociateWaitingVersionToDocuments(context_, pending_version());
-
+  DCHECK(!registration()->installing_version());
+  ResolvePromise(status, registration(), new_version());
+  registration()->SetInstallingVersion(new_version());
+  AssociateInstallingVersionToDocuments(context_, new_version());
   InstallAndContinue();
 }
 
 // This function corresponds to the spec's _Install algorithm.
 void ServiceWorkerRegisterJob::InstallAndContinue() {
   SetPhase(INSTALL);
   // "Set serviceWorkerRegistration.installingWorker._state to installing."
   // "Fire install event on the associated ServiceWorkerGlobalScope object."
-  pending_version()->DispatchInstallEvent(
+  new_version()->DispatchInstallEvent(
       -1,
       base::Bind(&ServiceWorkerRegisterJob::OnInstallFinished,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerRegisterJob::OnInstallFinished(
     ServiceWorkerStatusCode status) {
   // "If any handler called waitUntil()..." and the resulting promise
   // is rejected, abort.
   // TODO(kinuko,falken): For some error cases (e.g. ServiceWorker is
   // unexpectedly terminated) we may want to retry sending the event again.
   if (status != SERVICE_WORKER_OK) {
     Complete(status);
     return;
   }
 
   SetPhase(STORE);
   context_->storage()->StoreRegistration(
       registration(),
-      pending_version(),
+      new_version(),
       base::Bind(&ServiceWorkerRegisterJob::OnStoreRegistrationComplete,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerRegisterJob::OnStoreRegistrationComplete(
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK) {
     Complete(status);
     return;
   }
-
+  registration()->SetWaitingVersion(new_version());
   ActivateAndContinue();
 }
 
 // This function corresponds to the spec's _Activate algorithm.
 void ServiceWorkerRegisterJob::ActivateAndContinue() {
   SetPhase(ACTIVATE);
 
   // "If existingWorker is not null, then: wait for exitingWorker to finish
   // handling any in-progress requests."
   // See if we already have an active_version for the scope and it has
   // controllee documents (if so activating the new version should wait
   // until we have no documents controlled by the version).
   if (registration()->active_version() &&
       registration()->active_version()->HasControllee()) {
     // TODO(kinuko,falken): Currently we immediately return if the existing
     // registration already has an active version, so we shouldn't come
     // this way.
     NOTREACHED();
     // TODO(falken): Register an continuation task to wait for NoControllees
     // notification so that we can resume activation later (see comments
     // in ServiceWorkerVersion::RemoveControllee).
     Complete(SERVICE_WORKER_OK);
     return;
   }
 
   // "Set serviceWorkerRegistration.waitingWorker to null."
   // "Set serviceWorkerRegistration.activeWorker to activatingWorker."
-  DisassociateWaitingVersionFromDocuments(
-      context_, pending_version()->version_id());
-  registration()->set_waiting_version(NULL);
-  DCHECK(!registration()->active_version());
-  registration()->set_active_version(pending_version());
+  registration()->SetActiveVersion(new_version());
 
   // "Set serviceWorkerRegistration.activeWorker._state to activating."
   // "Fire activate event on the associated ServiceWorkerGlobalScope object."
   // "Set serviceWorkerRegistration.activeWorker._state to active."
-  pending_version()->DispatchActivateEvent(
+  new_version()->DispatchActivateEvent(
       base::Bind(&ServiceWorkerRegisterJob::OnActivateFinished,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerRegisterJob::OnActivateFinished(
     ServiceWorkerStatusCode status) {
   // "If any handler called waitUntil()..." and the resulting promise
   // is rejected, abort.
   // TODO(kinuko,falken): For some error cases (e.g. ServiceWorker is
   // unexpectedly terminated) we may want to retry sending the event again.
   if (status != SERVICE_WORKER_OK) {
-    registration()->set_active_version(NULL);
+    registration()->SetActiveVersion(NULL);
     Complete(status);
     return;
   }
   context_->storage()->UpdateToActiveState(
       registration(),
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   Complete(SERVICE_WORKER_OK);
 }
 
 void ServiceWorkerRegisterJob::Complete(ServiceWorkerStatusCode status) {
   CompleteInternal(status);
   context_->job_coordinator()->FinishJob(pattern_, this);
 }
 
 void ServiceWorkerRegisterJob::CompleteInternal(
     ServiceWorkerStatusCode status) {
   SetPhase(COMPLETE);
   if (status != SERVICE_WORKER_OK) {
-    if (registration() && registration()->waiting_version()) {
-      DisassociateWaitingVersionFromDocuments(
-          context_, registration()->waiting_version()->version_id());
-      registration()->set_waiting_version(NULL);
-    }
-    if (registration() && !registration()->active_version()) {
-      context_->storage()->DeleteRegistration(
-          registration()->id(),
-          registration()->script_url().GetOrigin(),
-          base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+    if (registration()) {
+      if (new_version()) {
+        DisassociateVersionFromDocuments(context_, new_version());
+        registration()->UnsetVersion(new_version());
+      }
+      if (!registration()->active_version()) {
+        context_->storage()->DeleteRegistration(
+            registration()->id(),
+            registration()->script_url().GetOrigin(),
+            base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+      }
     }
     if (!is_promise_resolved_)
       ResolvePromise(status, NULL, NULL);
   }
   DCHECK(callbacks_.empty());
   if (registration()) {
     context_->storage()->NotifyDoneInstallingRegistration(
-        registration(), pending_version(), status);
+        registration(), new_version(), status);
   }
-  if (pending_version())
-    pending_version()->embedded_worker()->RemoveListener(this);
+  if (new_version())
+    new_version()->embedded_worker()->RemoveListener(this);
 }
 
 void ServiceWorkerRegisterJob::ResolvePromise(
     ServiceWorkerStatusCode status,
     ServiceWorkerRegistration* registration,
     ServiceWorkerVersion* version) {
   DCHECK(!is_promise_resolved_);
   is_promise_resolved_ = true;
   promise_resolved_status_ = status;
   promise_resolved_registration_ = registration;
   promise_resolved_version_ = version;
   for (std::vector<RegistrationCallback>::iterator it = callbacks_.begin();
        it != callbacks_.end();
        ++it) {
     it->Run(status, registration, version);
   }
   callbacks_.clear();
 }
 
 void ServiceWorkerRegisterJob::OnPausedAfterDownload() {
   // TODO(michaeln): Compare the old and new script.
   // If different unpause the worker and continue with
   // the job. If the same ResolvePromise with the current
   // version and complete the job, throwing away the new version
   // since there's nothing new.

[falken, 2014/07/02 05:42:11]

Now we have this comment twice.

[michaeln, 2014/07/02 23:17:14]

Done.

-  pending_version()->embedded_worker()->RemoveListener(this);
-  pending_version()->embedded_worker()->ResumeAfterDownload();
+  new_version()->embedded_worker()->RemoveListener(this);
+  new_version()->embedded_worker()->ResumeAfterDownload();
 }
 
 bool ServiceWorkerRegisterJob::OnMessageReceived(const IPC::Message& message) {
   return false;
 }
 
 // static
-void ServiceWorkerRegisterJob::AssociateWaitingVersionToDocuments(
+void ServiceWorkerRegisterJob::AssociateInstallingVersionToDocuments(
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerVersion* version) {
   DCHECK(context);
   DCHECK(version);
 
   for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
            context->GetProviderHostIterator();
-       !it->IsAtEnd();
-       it->Advance()) {
+       !it->IsAtEnd();  it->Advance()) {
     ServiceWorkerProviderHost* host = it->GetProviderHost();
-    if (!host->IsContextAlive())
-      continue;

[falken, 2014/07/02 05:42:11]

I wonder why this was here. Is it possible the provider host can have a dead
context if there was a db corruption recovery? I vaguely remember talking to
nhiroki about this function. +nhiroki

[nhiroki, 2014/07/02 07:25:12]

Right. After the corruption recovery, there can be hosts referring to the dead
context, so we needed to check it before associating the version.

In michael's patch, CanAssociateVersion() checks it so this deletion should be
OK. (I like this way. Thank you for cleaning up :)

     if (ServiceWorkerUtils::ScopeMatches(version->scope(),
                                          host->document_url())) {
-      // The spec's _Update algorithm says, "upgrades active version to a new
-      // version for the same URL scope.", so skip if the scope (registration)
-      // of |version| is different from that of the current active/waiting
-      // version.
-      if (!host->ValidateVersionForAssociation(version))
+      if (!host->CanAssociateVersion(version))
         continue;
-
-      // TODO(nhiroki): Keep |host->waiting_version()| to be replaced and set
-      // status of them to 'redandunt' after breaking the loop.
-
-      host->SetWaitingVersion(version);
-      // TODO(nhiroki): Set |host|'s installing version to null.
+      host->SetInstallingVersion(version);
     }
   }
 }
 
 // static
-void ServiceWorkerRegisterJob::DisassociateWaitingVersionFromDocuments(
+void ServiceWorkerRegisterJob::DisassociateVersionFromDocuments(
     base::WeakPtr<ServiceWorkerContextCore> context,
-    int64 version_id) {
+    ServiceWorkerVersion* version) {
   DCHECK(context);
   for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
            context->GetProviderHostIterator();
-       !it->IsAtEnd();
-       it->Advance()) {
+       !it->IsAtEnd(); it->Advance()) {
     ServiceWorkerProviderHost* host = it->GetProviderHost();
-    if (!host->IsContextAlive())
-      continue;
-    if (host->waiting_version() &&
-        host->waiting_version()->version_id() == version_id) {
-      host->SetWaitingVersion(NULL);
-    }
+    host->UnsetVersion(version);
   }
 }
 
 }  // namespace content