ServiceWorker: Move worker candidate process knowledge to ServiceWorkerProcessManager.

content/browser/service_worker/service_worker_version.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_version.h"
 
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
+#include "content/browser/service_worker/service_worker_process_manager.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 
 namespace content {
 
 typedef ServiceWorkerVersion::StatusCallback StatusCallback;
 typedef ServiceWorkerVersion::MessageCallback MessageCallback;
@@ skipping 126 matching lines @@
   return ServiceWorkerVersionInfo(
       running_status(),
       status(),
       version_id(),
       embedded_worker()->process_id(),
       embedded_worker()->thread_id(),
       embedded_worker()->worker_devtools_agent_route_id());
 }
 
 void ServiceWorkerVersion::StartWorker(const StatusCallback& callback) {
-  StartWorkerWithCandidateProcesses(std::vector<int>(), false, callback);
+  StartWorker(false, callback);
 }
 
-void ServiceWorkerVersion::StartWorkerWithCandidateProcesses(
-    const std::vector<int>& possible_process_ids,
+void ServiceWorkerVersion::StartWorker(
     bool pause_after_download,
     const StatusCallback& callback) {
   switch (running_status()) {
     case RUNNING:
       RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
       return;
     case STOPPING:
       RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_START_WORKER_FAILED));
       return;
     case STOPPED:
     case STARTING:
       start_callbacks_.push_back(callback);
       if (running_status() == STOPPED) {
         embedded_worker_->Start(
             version_id_,
             scope_,
             script_url_,
             pause_after_download,
-            possible_process_ids,
             base::Bind(&ServiceWorkerVersion::RunStartWorkerCallbacksOnError,
                        weak_factory_.GetWeakPtr()));
       }
       return;
   }
 }
 
 void ServiceWorkerVersion::StopWorker(const StatusCallback& callback) {
   if (running_status() == STOPPED) {
     RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
@@ skipping 168 matching lines @@
   int request_id = push_callbacks_.Add(new StatusCallback(callback));
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_PushEvent(request_id, data));
   if (status != SERVICE_WORKER_OK) {
     push_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
 void ServiceWorkerVersion::AddProcessToWorker(int process_id) {
-  embedded_worker_->AddProcessReference(process_id);
+  if (context_ && context_->process_manager()) {
+    context_->process_manager()->AddScopeProcessReference(
+        scope_, process_id);
+  }
 }
 
 void ServiceWorkerVersion::RemoveProcessFromWorker(int process_id) {
-  embedded_worker_->ReleaseProcessReference(process_id);
-}
-
-bool ServiceWorkerVersion::HasProcessToRun() const {
-  return embedded_worker_->HasProcessToRun();
+  if (context_ && context_->process_manager()) {
+    context_->process_manager()->RemoveScopeProcessReference(
+        scope_, process_id);
+  }
 }
 
 void ServiceWorkerVersion::AddControllee(
     ServiceWorkerProviderHost* provider_host) {
   DCHECK(!ContainsKey(controllee_map_, provider_host));
   int controllee_id = controllee_by_id_.Add(provider_host);
   controllee_map_[provider_host] = controllee_id;
   AddProcessToWorker(provider_host->process_id());
   if (stop_worker_timer_.IsRunning())
     stop_worker_timer_.Stop();
@@ skipping 19 matching lines @@
 void ServiceWorkerVersion::AddPotentialControllee(
     ServiceWorkerProviderHost* provider_host) {
   AddProcessToWorker(provider_host->process_id());
 }
 
 void ServiceWorkerVersion::RemovePotentialControllee(
     ServiceWorkerProviderHost* provider_host) {
   RemoveProcessFromWorker(provider_host->process_id());
 }
 
+void ServiceWorkerVersion::AddPendingProcesses(
+    const std::vector<int>& pending_processes) {
+  if (context_ && context_->process_manager() && !pending_processes.empty()) {
+    context_->process_manager()->AddScopePendingProcesses(
+        scope_, pending_processes);
+  }
+}
+
 void ServiceWorkerVersion::AddListener(Listener* listener) {
   listeners_.AddObserver(listener);
 }
 
 void ServiceWorkerVersion::RemoveListener(Listener* listener) {
   listeners_.RemoveObserver(listener);
 }
 
 void ServiceWorkerVersion::Doom() {
   if (is_doomed_)
@@ skipping 259 matching lines @@
   SetStatus(REDUNDANT);
   StopWorker(base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   if (!context_)
     return;
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   script_cache_map_.GetResources(&resources);
   context_->storage()->PurgeResources(resources);
 }
 
 }  // namespace content