ServiceWorker: Make SWProviderHost listen to SWRegistration

content/browser/service_worker/service_worker_registration.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_registration.h"
 
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_info.h"
 #include "content/browser/service_worker/service_worker_register_job.h"
 #include "content/browser/service_worker/service_worker_utils.h"
@@ skipping 22 matching lines @@
       is_deleted_(false),
       should_activate_when_ready_(false),
       context_(context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(context_);
   context_->AddLiveRegistration(this);
 }
 
 ServiceWorkerRegistration::~ServiceWorkerRegistration() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!listeners_.might_have_observers());
   if (context_)
     context_->RemoveLiveRegistration(registration_id_);
   ResetShouldActivateWhenReady();
 }
 
 void ServiceWorkerRegistration::AddListener(Listener* listener) {
   listeners_.AddObserver(listener);
 }
 
 void ServiceWorkerRegistration::RemoveListener(Listener* listener) {
@@ skipping 81 matching lines @@
   if (should_activate_when_ready_)
     return;
   if (active_version() && active_version()->HasControllee()) {
     active_version()->AddListener(this);
     should_activate_when_ready_ = true;
     return;
   }
   ActivateWaitingVersion();
 }
 
+void ServiceWorkerRegistration::SetIsDeleted() {
+  is_deleted_ = true;
+  FOR_EACH_OBSERVER(Listener, listeners_, OnRegistrationDeleted(this));
+}
+
 void ServiceWorkerRegistration::OnNoControllees(ServiceWorkerVersion* version) {
   DCHECK_EQ(active_version(), version);
   DCHECK(should_activate_when_ready_);
   active_version_->RemoveListener(this);
   should_activate_when_ready_ = false;
   ActivateWaitingVersion();
 }
 
 void ServiceWorkerRegistration::ActivateWaitingVersion() {
   DCHECK(context_);
@@ skipping 14 matching lines @@
     // "2. Terminate exitingWorker."
     exiting_version->StopWorker(
         base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
     // "3. Run the [[UpdateState]] algorithm passing exitingWorker and
     // "redundant" as the arguments."
     exiting_version->SetStatus(ServiceWorkerVersion::REDUNDANT);
   }
 
   // "5. Set serviceWorkerRegistration.activeWorker to activatingWorker."
   // "6. Set serviceWorkerRegistration.waitingWorker to null."
-  ServiceWorkerRegisterJob::DisassociateVersionFromDocuments(
-      context_, activating_version);
   SetActiveVersion(activating_version);
-  ServiceWorkerRegisterJob::AssociateActiveVersionToDocuments(
-      context_, activating_version);
 
   // "7. Run the [[UpdateState]] algorithm passing registration.activeWorker and
   // "activating" as arguments."
   activating_version->SetStatus(ServiceWorkerVersion::ACTIVATING);
 
   // TODO(nhiroki): "8. Fire a simple event named controllerchange..."
 
   // "9. Queue a task to fire an event named activate..."
   activating_version->DispatchActivateEvent(
       base::Bind(&ServiceWorkerRegistration::OnActivateEventFinished,
                  this, activating_version));
 }
 
 void ServiceWorkerRegistration::OnActivateEventFinished(
     ServiceWorkerVersion* activating_version,
     ServiceWorkerStatusCode status) {
   if (!context_ || activating_version != active_version())
     return;
   // 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) {
     // "11. If activateFailed is true, then:..."
-    ServiceWorkerRegisterJob::DisassociateVersionFromDocuments(
-        context_, activating_version);
     UnsetVersion(activating_version);
     activating_version->Doom();
     if (!waiting_version()) {
       // Delete the records from the db.
       context_->storage()->DeleteRegistration(
           id(), script_url().GetOrigin(),
           base::Bind(&ServiceWorkerRegistration::OnDeleteFinished, this));
       // But not from memory if there is a version in the pipeline.
       if (installing_version())
         is_deleted_ = false;

[falken, 2014/08/06 16:09:35]

As here, it's possible to flip back out of is_deleted_. So I'm not sure
listening for the moment is_deleted_ turns true then cutting ties with the
registration is right.

[michaeln, 2014/08/07 01:34:35]

agreed that its not deletion that matters so much as registration that fails to
launch (so to speak), maybe the most direct way to handle this is to have the
RegistrationJob use another helper to UnassociateFailedRegistration.

[nhiroki, 2014/08/07 02:57:27]

Acknowledged.

     }
     return;
   }
 
   // "12. Run the [[UpdateState]] algorithm passing registration.activeWorker
   // and "activated" as the arguments."
   activating_version->SetStatus(ServiceWorkerVersion::ACTIVATED);
   if (context_) {
     context_->storage()->UpdateToActiveState(
         this,
         base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   }
 }
 
 void ServiceWorkerRegistration::ResetShouldActivateWhenReady() {
   if (should_activate_when_ready_) {
     active_version()->RemoveListener(this);
     should_activate_when_ready_ = false;
   }
 }
 
 void ServiceWorkerRegistration::OnDeleteFinished(
     ServiceWorkerStatusCode status) {
   // Intentionally empty completion callback, used to prevent
   // |this| from being deleted until the storage method completes.
 }
 
 }  // namespace content