ServiceWorker: Make SWProviderHost listen to SWRegistration

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 165 matching lines @@
     Complete(status);
     return;
   }
 
   // "If serviceWorkerRegistration is not null and script is equal to
   // serviceWorkerRegistration.scriptUrl..." resolve with the existing
   // registration and abort.
   if (existing_registration.get() &&
       existing_registration->script_url() == script_url_) {
     set_registration(existing_registration);
+    AssociateProviderHostToRegistration(existing_registration);
     // If there's no active version, go ahead to Update (this isn't in the spec
     // but seems reasonable, and without SoftUpdate implemented we can never
     // Update otherwise).
     if (!existing_registration->active_version()) {
       UpdateAndContinue();
       return;
     }
     ResolvePromise(
         status, existing_registration, existing_registration->active_version());
     Complete(SERVICE_WORKER_OK);
@@ skipping 44 matching lines @@
   SetPhase(REGISTER);
   if (status != SERVICE_WORKER_OK) {
     // Abort this registration job.
     Complete(status);
     return;
   }
 
   set_registration(new ServiceWorkerRegistration(
       pattern_, script_url_, context_->storage()->NewRegistrationId(),
       context_));
+  AssociateProviderHostToRegistration(registration());
   UpdateAndContinue();
 }
 
 // This function corresponds to the spec's [[Update]] algorithm.
 void ServiceWorkerRegisterJob::UpdateAndContinue() {
   SetPhase(UPDATE);
   context_->storage()->NotifyInstallingRegistration(registration());
 
   // TODO(falken): "If serviceWorkerRegistration.installingWorker is not null.."
   // then terminate the installing worker. It doesn't make sense to implement
@@ skipping 29 matching lines @@
   ResolvePromise(status, registration(), new_version());
   InstallAndContinue();
 }
 
 // This function corresponds to the spec's _Install algorithm.
 void ServiceWorkerRegisterJob::InstallAndContinue() {
   SetPhase(INSTALL);
 
   // "3. Set registration.installingWorker to worker."
   registration()->SetInstallingVersion(new_version());
-  AssociateInstallingVersionToDocuments(context_, new_version());
 
   // "4. Run the [[UpdateState]] algorithm passing registration.installingWorker
   // and "installing" as the arguments."
   new_version()->SetStatus(ServiceWorkerVersion::INSTALLING);
 
   // TODO(nhiroki,michaeln): "5. Fire a simple event named updatefound..."
 
   // "6. Fire an event named install..."
   new_version()->DispatchInstallEvent(
       -1,
@@ skipping 29 matching lines @@
   // "9. If registration.waitingWorker is not null, then:..."
   if (registration()->waiting_version()) {
     // "1. Run the [[UpdateState]] algorithm passing registration.waitingWorker
     // and "redundant" as the arguments."
     registration()->waiting_version()->SetStatus(
         ServiceWorkerVersion::REDUNDANT);
   }
 
   // "10. Set registration.waitingWorker to registration.installingWorker."
   // "11. Set registration.installingWorker to null."
-  DisassociateVersionFromDocuments(context_, new_version());
   registration()->SetWaitingVersion(new_version());
-  AssociateWaitingVersionToDocuments(context_, new_version());
 
   // "12. Run the [[UpdateState]] algorithm passing registration.waitingWorker
   // and "installed" as the arguments."
   new_version()->SetStatus(ServiceWorkerVersion::INSTALLED);
 
   // TODO(michaeln): "13. If activateImmediate is true, then..."
 
   // "14. Wait until no document is using registration as their
   // Service Worker registration."
   registration()->ActivateWaitingVersionWhenReady();
 
   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()) {
       if (new_version()) {
-        DisassociateVersionFromDocuments(context_, new_version());
         registration()->UnsetVersion(new_version());
         new_version()->Doom();
       }
       if (!registration()->active_version()) {
         context_->storage()->DeleteRegistration(
             registration()->id(),
             registration()->script_url().GetOrigin(),
             base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
       }
     }
@@ skipping 58 matching lines @@
     ResolvePromise(SERVICE_WORKER_OK, registration(), current_version);
     Complete(SERVICE_WORKER_ERROR_EXISTS);
     return;
   }
 
   // Proceed with really starting the worker.
   new_version()->embedded_worker()->ResumeAfterDownload();
   new_version()->embedded_worker()->RemoveListener(this);
 }
 
-// static
-void ServiceWorkerRegisterJob::AssociateInstallingVersionToDocuments(
-    base::WeakPtr<ServiceWorkerContextCore> context,
-    ServiceWorkerVersion* version) {
-  DCHECK(context);
-  DCHECK(version);
-
+void ServiceWorkerRegisterJob::AssociateProviderHostToRegistration(
+    ServiceWorkerRegistration* registration) {
+  DCHECK(registration);
   for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
-           context->GetProviderHostIterator();
+           context_->GetProviderHostIterator();
        !it->IsAtEnd(); it->Advance()) {
     ServiceWorkerProviderHost* host = it->GetProviderHost();
-    if (ServiceWorkerUtils::ScopeMatches(version->scope(),
+    if (ServiceWorkerUtils::ScopeMatches(registration->pattern(),
                                          host->document_url())) {
-      if (!host->CanAssociateVersion(version))
-        continue;
-      host->SetInstallingVersion(version);
+      host->AssociateRegistration(registration);

[falken, 2014/08/05 02:41:28]

I wonder what happens in cases like register(), load a document, unregister(),
then register() again. The loaded document won't change registration, but it
should get updated installing/waiting versions. I guess this is already broken
and the spec'd behavior may change in
https://github.com/slightlyoff/ServiceWorker/issues/396

[nhiroki, 2014/08/05 15:51:13]

Thank you for sharing the issue. Yes, this is already broken.

Probably my subsequent CLs will revamp this part to implement '.installing' etc
on ServiceWorkerRegistration, so let me revisit then.

     }
   }
 }
 
-// static
-void ServiceWorkerRegisterJob::AssociateWaitingVersionToDocuments(
-    base::WeakPtr<ServiceWorkerContextCore> context,
-    ServiceWorkerVersion* version) {
-  DCHECK(context);
-  DCHECK(version);
-
-  for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
-           context->GetProviderHostIterator();
-       !it->IsAtEnd(); it->Advance()) {
-    ServiceWorkerProviderHost* host = it->GetProviderHost();
-    if (ServiceWorkerUtils::ScopeMatches(version->scope(),
-                                         host->document_url())) {
-      if (!host->CanAssociateVersion(version))
-        continue;
-      host->SetWaitingVersion(version);
-    }
-  }
-}
-
-// static
-void ServiceWorkerRegisterJob::AssociateActiveVersionToDocuments(
-    base::WeakPtr<ServiceWorkerContextCore> context,
-    ServiceWorkerVersion* version) {
-  DCHECK(context);
-  DCHECK(version);
-
-  for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
-           context->GetProviderHostIterator();
-       !it->IsAtEnd(); it->Advance()) {
-    ServiceWorkerProviderHost* host = it->GetProviderHost();
-    if (ServiceWorkerUtils::ScopeMatches(version->scope(),
-                                         host->document_url())) {
-      if (!host->CanAssociateVersion(version))
-        continue;
-      host->SetActiveVersion(version);
-    }
-  }
-}
-
-// static
-void ServiceWorkerRegisterJob::DisassociateVersionFromDocuments(
-    base::WeakPtr<ServiceWorkerContextCore> context,
-    ServiceWorkerVersion* version) {
-  DCHECK(context);
-  for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
-           context->GetProviderHostIterator();
-       !it->IsAtEnd(); it->Advance()) {
-    ServiceWorkerProviderHost* host = it->GetProviderHost();
-    host->UnsetVersion(version);
-  }
-}
-
 }  // namespace content