Teach EmbeddedWorkerInstance to create a process when it needs one.

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 <vector>
 
 #include "base/basictypes.h"
@@ skipping 97 matching lines @@
   // if there're any (see RegisterStatusChangeCallback).
   void SetStatus(Status status);
 
   // 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);
+  // |potential_process_ids| is a list of processes in which to start the
+  // worker.
+  void StartWorker(
+      const StatusCallback& callback,
+      const std::vector<int>& potential_process_ids = std::vector<int>());

[kinuko, 2014/04/28 06:58:16]

Again, no optional parameters in chromium...  Could we have another method like,
StartWorkerWithCandidateProcesses() (as function overloading is not really
preferred either), which takes process_ids param?  StartWorker can internally
call it then.

[Jeffrey Yasskin, 2014/04/28 20:47:40]

Sure, done.

 
   // Starts an embedded worker for this version.
   // This returns OK (success) if the worker is already stopped.
   void StopWorker(const StatusCallback& callback);
 
   // Sends an IPC message to the worker.
   // If the worker is not running this first tries to start it by
   // calling StartWorker internally.
   // |callback| can be null if the sender does not need to know if the
   // message is successfully sent or not.
@@ skipping 76 matching lines @@
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
  private:
   typedef ServiceWorkerVersion self;
   typedef std::map<ServiceWorkerProviderHost*, int> ControlleeMap;
   typedef IDMap<ServiceWorkerProviderHost> ControlleeByIDMap;
   friend class base::RefCounted<ServiceWorkerVersion>;
 
   virtual ~ServiceWorkerVersion();
 
+  void RunStartWorkerCallbacksOnError(ServiceWorkerStatusCode status);
+
+  void DispatchInstallEventAfterStartWorker(int active_version_id,
+                                            const StatusCallback& callback);
+  void DispatchActivateEventAfterStartWorker(const StatusCallback& callback);
+
   // Message handlers.
   void OnGetClientDocuments(int request_id);
   void OnActivateEventFinished(int request_id,
                                blink::WebServiceWorkerEventResult result);
   void OnInstallEventFinished(int request_id,
                               blink::WebServiceWorkerEventResult result);
   void OnFetchEventFinished(int request_id,
                             ServiceWorkerFetchEventResult result,
                             const ServiceWorkerResponse& response);
   void OnSyncEventFinished(int request_id);
@@ skipping 20 matching lines @@
   ObserverList<Listener> listeners_;
 
   base::WeakPtrFactory<ServiceWorkerVersion> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersion);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_