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);
 
   // 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.
   void SendMessage(const IPC::Message& message, const StatusCallback& callback);
 
   // Sends install event to the associated embedded worker and asynchronously
   // calls |callback| when it errors out or it gets response from the worker
   // to notify install completion.
   // |active_version_id| must be a valid positive ID
   // if there's an active (previous) version running.
   //
   // This must be called when the status() is NEW. Calling this changes
   // the version's status to INSTALLING.
   // Upon completion, the version's status will be changed to INSTALLED
   // on success, or back to NEW on failure.
+  // |second_call| is for internal use.
   void DispatchInstallEvent(int active_version_id,
-                            const StatusCallback& callback);
+                            const StatusCallback& callback,
+                            bool second_call = false);
 
   // Sends activate event to the associated embedded worker and asynchronously
   // calls |callback| when it errors out or it gets response from the worker
   // to notify activation completion.
   //
   // This must be called when the status() is INSTALLED. Calling this changes
   // the version's status to ACTIVATING.
   // Upon completion, the version's status will be changed to ACTIVE
   // on success, or back to INSTALLED on failure.
-  void DispatchActivateEvent(const StatusCallback& callback);
+  // |second_call| is for internal use.
+  void DispatchActivateEvent(const StatusCallback& callback,
+                             bool second_call = false);
 
   // Sends fetch event to the associated embedded worker and calls
   // |callback| with the response from the worker.
   //
   // This must be called when the status() is ACTIVE. Calling this in other
   // statuses will result in an error SERVICE_WORKER_ERROR_FAILED.
   void DispatchFetchEvent(const ServiceWorkerFetchRequest& request,
                           const FetchCallback& callback);
 
   // Sends sync event to the associated embedded worker and asynchronously calls
@@ skipping 42 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);
+
   // 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_