ServiceWorker: Move worker candidate process knowledge to ServiceWorkerProcessManager.

content/browser/service_worker/service_worker_version.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 103 matching lines @@
   // Registers status change callback. (This is for one-off observation,
   // the consumer needs to re-register if it wants to continue observing
   // status changes)
   void RegisterStatusChangeCallback(const base::Closure& callback);
 
   // Starts an embedded worker for this version.
   // This returns OK (success) if the worker is already running.
   void StartWorker(const StatusCallback& callback);
 
   // Starts an embedded worker for this version.
-  // |potential_process_ids| is a list of processes in which to start the
-  // worker.
+  // |pause_after_download| is a flag to tell worker to pause after download.
   // This returns OK (success) if the worker is already running.
-  void StartWorkerWithCandidateProcesses(
-      const std::vector<int>& potential_process_ids,
-      bool pause_after_download,
-      const StatusCallback& callback);
+  void StartWorker(bool pause_after_download,
+                   const StatusCallback& callback);
 
   // Stops an embedded worker for this version.
   // This returns OK (success) if the worker is already stopped.
   void StopWorker(const StatusCallback& callback);
 
   // Schedules an update to be run 'soon'.
   void ScheduleUpdate();
 
   // If an update is scheduled but not yet started, this resets the timer
   // delaying the start time by a 'small' amount.
@@ skipping 54 matching lines @@
   // This must be called when the status() is ACTIVATED.
   void DispatchPushEvent(const StatusCallback& callback,
                          const std::string& data);
 
   // These are expected to be called when a renderer process host for the
   // same-origin as for this ServiceWorkerVersion is created.  The added
   // processes are used to run an in-renderer embedded worker.
   void AddProcessToWorker(int process_id);
   void RemoveProcessFromWorker(int process_id);
 
-  // Returns true if this has at least one process to run.
-  bool HasProcessToRun() const;
-
   // Adds and removes |provider_host| as a controllee of this ServiceWorker.
   // A potential controllee is a host having the version as its .installing
   // or .waiting version.
   void AddControllee(ServiceWorkerProviderHost* provider_host);
   void RemoveControllee(ServiceWorkerProviderHost* provider_host);
   void AddPotentialControllee(ServiceWorkerProviderHost* provider_host);
   void RemovePotentialControllee(ServiceWorkerProviderHost* provider_host);
 
+  // Notifies process manager about the callback pending renderer processes.
+  void AddPendingProcesses(const std::vector<int>& pending_processes);
+
   // Returns if it has controllee.
   bool HasControllee() const { return !controllee_map_.empty(); }
 
   // Adds and removes Listeners.
   void AddListener(Listener* listener);
   void RemoveListener(Listener* listener);
 
   ServiceWorkerScriptCacheMap* script_cache_map() { return &script_cache_map_; }
   EmbeddedWorkerInstance* embedded_worker() { return embedded_worker_.get(); }
 
@@ skipping 79 matching lines @@
   bool is_doomed_;
 
   base::WeakPtrFactory<ServiceWorkerVersion> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersion);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_