Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / content / browser / service_worker / embedded_worker_registry.h

diff --git a/src/content/browser/service_worker/embedded_worker_registry.h b/src/content/browser/service_worker/embedded_worker_registry.h
index 6645b7b..24b5b69 100644 (file)
--- a/src/content/browser/service_worker/embedded_worker_registry.h
+++ b/src/content/browser/service_worker/embedded_worker_registry.h
@@ -7,14 +7,17 @@
 
 #include <map>
 #include <set>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "base/strings/string16.h"
 #include "content/common/content_export.h"
 #include "content/common/service_worker/service_worker_status_code.h"
 
+struct EmbeddedWorkerMsg_StartWorker_Params;
 class GURL;
 
 namespace IPC {
@@ -35,28 +38,47 @@ class ServiceWorkerContextCore;
 class CONTENT_EXPORT EmbeddedWorkerRegistry
     : public NON_EXPORTED_BASE(base::RefCounted<EmbeddedWorkerRegistry>) {
  public:
+  typedef base::Callback<void(ServiceWorkerStatusCode)> StatusCallback;
+
   explicit EmbeddedWorkerRegistry(
       base::WeakPtr<ServiceWorkerContextCore> context);
 
+  bool OnMessageReceived(const IPC::Message& message);
+
   // Creates and removes a new worker instance entry for bookkeeping.
   // This doesn't actually start or stop the worker.
   scoped_ptr<EmbeddedWorkerInstance> CreateWorker();
 
   // Called from EmbeddedWorkerInstance, relayed to the child process.
-  ServiceWorkerStatusCode StartWorker(int process_id,
-                                      int embedded_worker_id,
-                                      int64 service_worker_version_id,
-                                      const GURL& script_url);
+  void StartWorker(const std::vector<int>& process_ids,
+                   int embedded_worker_id,
+                   int64 service_worker_version_id,
+                   const GURL& scope,
+                   const GURL& script_url,
+                   const StatusCallback& callback);
   ServiceWorkerStatusCode StopWorker(int process_id,
                                      int embedded_worker_id);
 
+  // Stop all active workers, even if they're handling events.
+  void Shutdown();
+
   // Called back from EmbeddedWorker in the child process, relayed via
   // ServiceWorkerDispatcherHost.
+  void OnWorkerScriptLoaded(int process_id, int embedded_worker_id);
+  void OnWorkerScriptLoadFailed(int process_id, int embedded_worker_id);
   void OnWorkerStarted(int process_id, int thread_id, int embedded_worker_id);
   void OnWorkerStopped(int process_id, int embedded_worker_id);
-  void OnSendMessageToBrowser(int embedded_worker_id,
-                              int request_id,
-                              const IPC::Message& message);
+  void OnReportException(int embedded_worker_id,
+                         const base::string16& error_message,
+                         int line_number,
+                         int column_number,
+                         const GURL& source_url);
+  void OnReportConsoleMessage(int embedded_worker_id,
+                              int source_identifier,
+                              int message_level,
+                              const base::string16& message,
+                              int line_number,
+                              const GURL& source_url);
 
   // Keeps a map from process_id to sender information.
   void AddChildProcessSender(int process_id, IPC::Sender* sender);
@@ -73,6 +95,14 @@ class CONTENT_EXPORT EmbeddedWorkerRegistry
   typedef std::map<int, IPC::Sender*> ProcessToSenderMap;
 
   ~EmbeddedWorkerRegistry();
+
+  void StartWorkerWithProcessId(
+      int embedded_worker_id,
+      scoped_ptr<EmbeddedWorkerMsg_StartWorker_Params> params,
+      const StatusCallback& callback,
+      ServiceWorkerStatusCode status,
+      int process_id);
+
   ServiceWorkerStatusCode Send(int process_id, IPC::Message* message);
 
   // RemoveWorker is called when EmbeddedWorkerInstance is destructed.