ServiceWorker: Move worker candidate process knowledge to ServiceWorkerProcessManager.

content/browser/service_worker/service_worker_provider_host.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_provider_host.h"
 
 #include "base/stl_util.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_request_handler.h"
@@ skipping 19 matching lines @@
       context_(context),
       dispatcher_host_(dispatcher_host) {
 }
 
 ServiceWorkerProviderHost::~ServiceWorkerProviderHost() {
   // Clear docurl so the deferred activation of a waiting worker
   // won't associate the new version with a provider being destroyed.
   document_url_ = GURL();
   if (controlling_version_.get())
     controlling_version_->RemoveControllee(this);
-  if (active_version_.get())
-    active_version_->RemovePotentialControllee(this);
-  if (waiting_version_.get())
-    waiting_version_->RemovePotentialControllee(this);
-  if (installing_version_.get())
-    installing_version_->RemovePotentialControllee(this);
-  if (associated_registration_.get())
+  if (associated_registration_.get()) {
+    DecreaseProcessReference(associated_registration_->pattern());
     associated_registration_->RemoveListener(this);
+  }
+  for (std::vector<GURL>::iterator it = associated_patterns_.begin();
+       it != associated_patterns_.end(); ++it) {
+    DecreaseProcessReference(*it);
+  }
 }
 
 void ServiceWorkerProviderHost::OnVersionAttributesChanged(
     ServiceWorkerRegistration* registration,
     ChangedVersionAttributesMask changed_mask,
     const ServiceWorkerRegistrationInfo& info) {
   DCHECK_EQ(associated_registration_.get(), registration);
-  UpdatePotentialControllees(registration->installing_version(),
-                             registration->waiting_version(),
-                             registration->active_version());
+  installing_version_ = registration->installing_version();
+  waiting_version_ = registration->waiting_version();
+  active_version_ = registration->active_version();
 }
 
 void ServiceWorkerProviderHost::OnRegistrationFailed(
     ServiceWorkerRegistration* registration) {
   DCHECK_EQ(associated_registration_.get(), registration);
   UnassociateRegistration();
 }
 
 void ServiceWorkerProviderHost::SetDocumentUrl(const GURL& url) {
   DCHECK(!url.has_ref());
   document_url_ = url;
 }
 
-void ServiceWorkerProviderHost::UpdatePotentialControllees(
-    ServiceWorkerVersion* installing_version,
-    ServiceWorkerVersion* waiting_version,
-    ServiceWorkerVersion* active_version) {
-   if (installing_version != installing_version_.get()) {
-     scoped_refptr<ServiceWorkerVersion> previous_version = installing_version_;
-     if (previous_version.get())
-       previous_version->RemovePotentialControllee(this);
-     if (installing_version)
-       installing_version->AddPotentialControllee(this);
-     installing_version_ = installing_version;
-   }
-
-   if (waiting_version != waiting_version_.get()) {
-     scoped_refptr<ServiceWorkerVersion> previous_version = waiting_version_;
-     if (previous_version.get())
-       previous_version->RemovePotentialControllee(this);
-     if (waiting_version)
-       waiting_version->AddPotentialControllee(this);
-     waiting_version_ = waiting_version;
-   }
-
-   if (active_version != active_version_.get()) {
-     scoped_refptr<ServiceWorkerVersion> previous_version = active_version_;
-     if (previous_version.get())
-       previous_version->RemovePotentialControllee(this);
-     if (active_version)
-       active_version->AddPotentialControllee(this);
-     active_version_ = active_version;
-   }
-}
-
 void ServiceWorkerProviderHost::SetControllerVersionAttribute(
     ServiceWorkerVersion* version) {
   if (version == controlling_version_.get())
     return;
 
   scoped_refptr<ServiceWorkerVersion> previous_version = controlling_version_;
   controlling_version_ = version;
   if (version)
     version->AddControllee(this);
   if (previous_version.get())
@@ skipping 24 matching lines @@
     return false;
   }
 
   running_hosted_version_ = live_version;
   return true;
 }
 
 void ServiceWorkerProviderHost::AssociateRegistration(
     ServiceWorkerRegistration* registration) {
   DCHECK(CanAssociateRegistration(registration));
+  if (associated_registration_.get())
+    DecreaseProcessReference(associated_registration_->pattern());
+  IncreaseProcessReference(registration->pattern());
+
   associated_registration_ = registration;
   registration->AddListener(this);
-  UpdatePotentialControllees(registration->installing_version(),
-                             registration->waiting_version(),
-                             registration->active_version());
+  installing_version_ = registration->installing_version();
+  waiting_version_ = registration->waiting_version();
+  active_version_ = registration->active_version();
   SetControllerVersionAttribute(registration->active_version());
 }
 
 void ServiceWorkerProviderHost::UnassociateRegistration() {
   if (!associated_registration_.get())
     return;
+  DecreaseProcessReference(associated_registration_->pattern());
   associated_registration_->RemoveListener(this);
   associated_registration_ = NULL;
-  UpdatePotentialControllees(NULL, NULL, NULL);
+  installing_version_ = NULL;
+  waiting_version_ = NULL;
+  active_version_ = NULL;
   SetControllerVersionAttribute(NULL);
 }
 
 scoped_ptr<ServiceWorkerRequestHandler>
 ServiceWorkerProviderHost::CreateRequestHandler(
     ResourceType resource_type,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     scoped_refptr<ResourceRequestBody> body) {
   if (IsHostToRunningServiceWorker()) {
     return scoped_ptr<ServiceWorkerRequestHandler>(
@@ skipping 32 matching lines @@
                                       &new_routing_ids);
 
   dispatcher_host_->Send(
       new ServiceWorkerMsg_MessageToDocument(
           kDocumentMainThreadId, provider_id(),
           message,
           sent_message_port_ids,
           new_routing_ids));
 }
 
+void ServiceWorkerProviderHost::AddScopedProcessReferenceToPattern(
+    const GURL& pattern) {
+  associated_patterns_.push_back(pattern);
+  IncreaseProcessReference(pattern);
+}
+
 ServiceWorkerObjectInfo ServiceWorkerProviderHost::CreateHandleAndPass(
     ServiceWorkerVersion* version) {
   ServiceWorkerObjectInfo info;
   if (context_ && version) {
     scoped_ptr<ServiceWorkerHandle> handle =
         ServiceWorkerHandle::Create(context_,
                                     dispatcher_host_,
                                     kDocumentMainThreadId,
                                     provider_id_,
                                     version);
     info = handle->GetObjectInfo();
     dispatcher_host_->RegisterServiceWorkerHandle(handle.Pass());
   }
   return info;
 }
 
+void ServiceWorkerProviderHost::IncreaseProcessReference(
+    const GURL& pattern) {
+  if (context_ && context_->process_manager()) {
+    context_->process_manager()->AddProcessReferenceToPattern(
+        pattern, process_id_);
+  }
+}
+
+void ServiceWorkerProviderHost::DecreaseProcessReference(
+    const GURL& pattern) {
+  if (context_ && context_->process_manager()) {
+    context_->process_manager()->RemoveProcessReferenceFromPattern(
+        pattern, process_id_);
+  }
+}
+
 bool ServiceWorkerProviderHost::IsContextAlive() {
   return context_ != NULL;
 }
 
 }  // namespace content