ServiceWorker: Rename 'pending version' to 'installing' or 'waiting'

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 158 matching lines @@
   // "If serviceWorkerRegistration is null..." create a new registration.
   if (!existing_registration.get()) {
     RegisterAndContinue(SERVICE_WORKER_OK);
     return;
   }
 
   // On script URL mismatch, "set serviceWorkerRegistration.scriptUrl to
   // script." We accomplish this by deleting the existing registration and
   // registering a new one.
   // TODO(falken): Match the spec. We now throw away the active_version_ and
-  // pending_version_ of the existing registration, which isn't in the spec.
+  // waiting_version_ of the existing registration, which isn't in the spec.
   // TODO(michaeln): Deactivate the live existing_registration object and
   // eventually call storage->DeleteVersionResources()
   // when it no longer has any controllees.
   context_->storage()->DeleteRegistration(
       existing_registration->id(),
       existing_registration->script_url().GetOrigin(),
       base::Bind(&ServiceWorkerRegisterJob::RegisterAndContinue,
                  weak_factory_.GetWeakPtr()));
 }
 
@@ skipping 17 matching lines @@
 // This function corresponds to the spec's _Update algorithm.
 void ServiceWorkerRegisterJob::UpdateAndContinue(
     ServiceWorkerStatusCode status) {
   SetPhase(UPDATE);
   if (status != SERVICE_WORKER_OK) {
     // Abort this registration job.
     Complete(status);
     return;
   }
 
-  // TODO(falken): "If serviceWorkerRegistration.pendingWorker is not null..."
-  // then terminate the pending worker. It doesn't make sense to implement yet
-  // since we always activate the worker if install completed, so there can be
-  // no pending worker at this point.
-  DCHECK(!registration()->pending_version());
+  // 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());
 
   // "Let serviceWorker be a newly-created ServiceWorker object..." and start
   // the worker.
   set_pending_version(new ServiceWorkerVersion(
       registration(), context_->storage()->NewVersionId(), context_));
 
   // TODO(michaeln): Start the worker into a paused state where the
   // script resource is downloaded but not yet evaluated.
   pending_version()->StartWorkerWithCandidateProcesses(
       pending_process_ids_,
@@ skipping 10 matching lines @@
     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 pendingWorker until after resolving the
+  // Although the spec doesn't set waitingWorker until after resolving the
   // promise, our system's resolving works by passing ServiceWorkerRegistration
-  // to the callbacks, so pendingWorker must be set first.
-  DCHECK(!registration()->pending_version());
-  registration()->set_pending_version(pending_version());
+  // to the callbacks, so waitingWorker must be set first.
+  DCHECK(!registration()->waiting_version());
+  registration()->set_waiting_version(pending_version());
   ResolvePromise(status, registration(), pending_version());
 
-  AssociatePendingVersionToDocuments(context_, pending_version());
+  AssociateWaitingVersionToDocuments(context_, pending_version());
 
   InstallAndContinue();
 }
 
 // This function corresponds to the spec's _Install algorithm.
 void ServiceWorkerRegisterJob::InstallAndContinue() {
   SetPhase(INSTALL);
-  // "Set serviceWorkerRegistration.pendingWorker._state to installing."
+  // "Set serviceWorkerRegistration.installingWorker._state to installing."
   // "Fire install event on the associated ServiceWorkerGlobalScope object."
   pending_version()->DispatchInstallEvent(
       -1,
       base::Bind(&ServiceWorkerRegisterJob::OnInstallFinished,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerRegisterJob::OnInstallFinished(
     ServiceWorkerStatusCode status) {
   // "If any handler called waitUntil()..." and the resulting promise
@@ skipping 38 matching lines @@
     // 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.pendingWorker to null."
+  // "Set serviceWorkerRegistration.waitingWorker to null."
   // "Set serviceWorkerRegistration.activeWorker to activatingWorker."
-  DisassociatePendingVersionFromDocuments(
+  DisassociateWaitingVersionFromDocuments(
       context_, pending_version()->version_id());
-  registration()->set_pending_version(NULL);
+  registration()->set_waiting_version(NULL);
   DCHECK(!registration()->active_version());
   registration()->set_active_version(pending_version());
 
   // "Set serviceWorkerRegistration.activeWorker._state to activating."
   // "Fire activate event on the associated ServiceWorkerGlobalScope object."
   // "Set serviceWorkerRegistration.activeWorker._state to active."
   pending_version()->DispatchActivateEvent(
       base::Bind(&ServiceWorkerRegisterJob::OnActivateFinished,
                  weak_factory_.GetWeakPtr()));
 }
@@ skipping 11 matching lines @@
   }
   context_->storage()->UpdateToActiveState(
       registration(),
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   Complete(SERVICE_WORKER_OK);
 }
 
 void ServiceWorkerRegisterJob::Complete(ServiceWorkerStatusCode status) {
   SetPhase(COMPLETE);
   if (status != SERVICE_WORKER_OK) {
-    if (registration() && registration()->pending_version()) {
-      DisassociatePendingVersionFromDocuments(
-          context_, registration()->pending_version()->version_id());
-      registration()->set_pending_version(NULL);
+    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 (!is_promise_resolved_)
       ResolvePromise(status, NULL, NULL);
   }
@@ skipping 16 matching lines @@
   promise_resolved_version_ = version;
   for (std::vector<RegistrationCallback>::iterator it = callbacks_.begin();
        it != callbacks_.end();
        ++it) {
     it->Run(status, registration, version);
   }
   callbacks_.clear();
 }
 
 // static
-void ServiceWorkerRegisterJob::AssociatePendingVersionToDocuments(
+void ServiceWorkerRegisterJob::AssociateWaitingVersionToDocuments(
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerVersion* version) {
   DCHECK(context);
   DCHECK(version);
 
   // TODO(michaeln): This needs to respect the longest prefix wins
   // when it comes to finding a registration for a document url.
   // This should utilize storage->FindRegistrationForDocument().
   for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
            context->GetProviderHostIterator();
        !it->IsAtEnd();
        it->Advance()) {
     ServiceWorkerProviderHost* host = it->GetProviderHost();
     if (ServiceWorkerUtils::ScopeMatches(version->scope(),
                                          host->document_url()))
-      host->SetPendingVersion(version);
+      host->SetWaitingVersion(version);
+      // TODO(nhiroki): Take care of 'installing' version when it's supported.
   }
 }
 
 // static
-void ServiceWorkerRegisterJob::DisassociatePendingVersionFromDocuments(
+void ServiceWorkerRegisterJob::DisassociateWaitingVersionFromDocuments(
     base::WeakPtr<ServiceWorkerContextCore> context,
     int64 version_id) {
   DCHECK(context);
   for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
            context->GetProviderHostIterator();
        !it->IsAtEnd();
        it->Advance()) {
     ServiceWorkerProviderHost* host = it->GetProviderHost();
-    if (host->pending_version() &&
-        host->pending_version()->version_id() == version_id) {
-      host->SetPendingVersion(NULL);
+    if (host->waiting_version() &&
+        host->waiting_version()->version_id() == version_id) {
+      host->SetWaitingVersion(NULL);
     }
   }
 }
 
 }  // namespace content