Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / content / browser / service_worker / embedded_worker_test_helper.cc

diff --git a/src/content/browser/service_worker/embedded_worker_test_helper.cc b/src/content/browser/service_worker/embedded_worker_test_helper.cc
index 70f7f0c..e6f8ce5 100644 (file)
--- a/src/content/browser/service_worker/embedded_worker_test_helper.cc
+++ b/src/content/browser/service_worker/embedded_worker_test_helper.cc
@@ -8,22 +8,35 @@
 #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_context_wrapper.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
-EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(
-    ServiceWorkerContextCore* context,
-    int mock_render_process_id)
-    : context_(context->AsWeakPtr()),
+static bool AlwaysTrue(int process_id) {
+  return true;
+}
+
+EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(int mock_render_process_id)
+    : wrapper_(new ServiceWorkerContextWrapper(NULL)),
       next_thread_id_(0),
       weak_factory_(this) {
+  wrapper_->InitForTesting(base::FilePath(),
+                           base::MessageLoopProxy::current(),
+                           NULL);
+  scoped_ptr<ServiceWorkerProcessManager> process_manager(
+      new ServiceWorkerProcessManager(wrapper_));
+  process_manager->SetProcessRefcountOpsForTest(base::Bind(AlwaysTrue),
+                                                base::Bind(AlwaysTrue));
+  wrapper_->context()->SetProcessManagerForTest(process_manager.Pass());
   registry()->AddChildProcessSender(mock_render_process_id, this);
 }
 
 EmbeddedWorkerTestHelper::~EmbeddedWorkerTestHelper() {
+  if (wrapper_)
+    wrapper_->Shutdown();
 }
 
 void EmbeddedWorkerTestHelper::SimulateAddProcessToWorker(
@@ -46,8 +59,8 @@ bool EmbeddedWorkerTestHelper::OnMessageReceived(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message)
     IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StartWorker, OnStartWorkerStub)
     IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StopWorker, OnStopWorkerStub)
-    IPC_MESSAGE_HANDLER(EmbeddedWorkerContextMsg_SendMessageToWorker,
-                        OnSendMessageToWorkerStub)
+    IPC_MESSAGE_HANDLER(EmbeddedWorkerContextMsg_MessageToWorker,
+                        OnMessageToWorkerStub)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
@@ -58,9 +71,19 @@ bool EmbeddedWorkerTestHelper::OnMessageReceived(const IPC::Message& message) {
   return handled;
 }
 
+ServiceWorkerContextCore* EmbeddedWorkerTestHelper::context() {
+  return wrapper_->context();
+}
+
+void EmbeddedWorkerTestHelper::ShutdownContext() {
+  wrapper_->Shutdown();
+  wrapper_ = NULL;
+}
+
 void EmbeddedWorkerTestHelper::OnStartWorker(
     int embedded_worker_id,
     int64 service_worker_version_id,
+    const GURL& scope,
     const GURL& script_url) {
   // By default just notify the sender that the worker is started.
   SimulateWorkerStarted(next_thread_id_++, embedded_worker_id);
@@ -71,13 +94,14 @@ void EmbeddedWorkerTestHelper::OnStopWorker(int embedded_worker_id) {
   SimulateWorkerStopped(embedded_worker_id);
 }
 
-bool EmbeddedWorkerTestHelper::OnSendMessageToWorker(
+bool EmbeddedWorkerTestHelper::OnMessageToWorker(
     int thread_id,
     int embedded_worker_id,
-    int request_id,
     const IPC::Message& message) {
   bool handled = true;
+  current_embedded_worker_id_ = embedded_worker_id;
   IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEventStub)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEventStub)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEventStub)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ -87,24 +111,30 @@ bool EmbeddedWorkerTestHelper::OnSendMessageToWorker(
   return handled;
 }
 
-void EmbeddedWorkerTestHelper::OnInstallEvent(
-    int embedded_worker_id,
-    int request_id,
-    int active_version_embedded_worker_id) {
-  SimulateSendMessageToBrowser(
-      embedded_worker_id,
-      request_id,
-      ServiceWorkerHostMsg_InstallEventFinished());
+void EmbeddedWorkerTestHelper::OnActivateEvent(int embedded_worker_id,
+                                               int request_id) {
+  SimulateSend(
+      new ServiceWorkerHostMsg_ActivateEventFinished(
+          embedded_worker_id, request_id,
+          blink::WebServiceWorkerEventResultCompleted));
+}
+
+void EmbeddedWorkerTestHelper::OnInstallEvent(int embedded_worker_id,
+                                              int request_id,
+                                              int active_version_id) {
+  SimulateSend(
+      new ServiceWorkerHostMsg_InstallEventFinished(
+          embedded_worker_id, request_id,
+          blink::WebServiceWorkerEventResultCompleted));
 }
 
 void EmbeddedWorkerTestHelper::OnFetchEvent(
     int embedded_worker_id,
     int request_id,
     const ServiceWorkerFetchRequest& request) {
-  SimulateSendMessageToBrowser(
-      embedded_worker_id,
-      request_id,
-      ServiceWorkerHostMsg_FetchEventFinished(
+  SimulateSend(
+      new ServiceWorkerHostMsg_FetchEventFinished(
+          embedded_worker_id, request_id,
           SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
           ServiceWorkerResponse(200, "OK", "GET",
                                 std::map<std::string, std::string>())));
@@ -127,25 +157,26 @@ void EmbeddedWorkerTestHelper::SimulateWorkerStopped(
   registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id);
 }
 
-void EmbeddedWorkerTestHelper::SimulateSendMessageToBrowser(
-    int embedded_worker_id, int request_id, const IPC::Message& message) {
-  registry()->OnSendMessageToBrowser(embedded_worker_id, request_id, message);
+void EmbeddedWorkerTestHelper::SimulateSend(
+    IPC::Message* message) {
+  registry()->OnMessageReceived(*message);
+  delete message;
 }
 
 void EmbeddedWorkerTestHelper::OnStartWorkerStub(
-    int embedded_worker_id,
-    int64 service_worker_version_id,
-    const GURL& script_url) {
-  EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
+    const EmbeddedWorkerMsg_StartWorker_Params& params) {
+  EmbeddedWorkerInstance* worker =
+      registry()->GetWorker(params.embedded_worker_id);
   ASSERT_TRUE(worker != NULL);
   EXPECT_EQ(EmbeddedWorkerInstance::STARTING, worker->status());
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker,
                  weak_factory_.GetWeakPtr(),
-                 embedded_worker_id,
-                 service_worker_version_id,
-                 script_url));
+                 params.embedded_worker_id,
+                 params.service_worker_version_id,
+                 params.scope,
+                 params.script_url));
 }
 
 void EmbeddedWorkerTestHelper::OnStopWorkerStub(int embedded_worker_id) {
@@ -158,52 +189,58 @@ void EmbeddedWorkerTestHelper::OnStopWorkerStub(int embedded_worker_id) {
                  embedded_worker_id));
 }
 
-void EmbeddedWorkerTestHelper::OnSendMessageToWorkerStub(
+void EmbeddedWorkerTestHelper::OnMessageToWorkerStub(
     int thread_id,
     int embedded_worker_id,
-    int request_id,
     const IPC::Message& message) {
-  current_embedded_worker_id_ = embedded_worker_id;
-  current_request_id_ = request_id;
   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
   ASSERT_TRUE(worker != NULL);
   EXPECT_EQ(worker->thread_id(), thread_id);
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(
-          base::IgnoreResult(&EmbeddedWorkerTestHelper::OnSendMessageToWorker),
+          base::IgnoreResult(&EmbeddedWorkerTestHelper::OnMessageToWorker),
           weak_factory_.GetWeakPtr(),
           thread_id,
           embedded_worker_id,
-          request_id,
           message));
 }
 
-void EmbeddedWorkerTestHelper::OnInstallEventStub(
-    int active_version_embedded_worker_id) {
+void EmbeddedWorkerTestHelper::OnActivateEventStub(int request_id) {
+  base::MessageLoopProxy::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&EmbeddedWorkerTestHelper::OnActivateEvent,
+                 weak_factory_.GetWeakPtr(),
+                 current_embedded_worker_id_,
+                 request_id));
+}
+
+void EmbeddedWorkerTestHelper::OnInstallEventStub(int request_id,
+                                                  int active_version_id) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&EmbeddedWorkerTestHelper::OnInstallEvent,
                  weak_factory_.GetWeakPtr(),
                  current_embedded_worker_id_,
-                 current_request_id_,
-                 active_version_embedded_worker_id));
+                 request_id,
+                 active_version_id));
 }
 
 void EmbeddedWorkerTestHelper::OnFetchEventStub(
+    int request_id,
     const ServiceWorkerFetchRequest& request) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&EmbeddedWorkerTestHelper::OnFetchEvent,
                  weak_factory_.GetWeakPtr(),
                  current_embedded_worker_id_,
-                 current_request_id_,
+                 request_id,
                  request));
 }
 
 EmbeddedWorkerRegistry* EmbeddedWorkerTestHelper::registry() {
-  DCHECK(context_);
-  return context_->embedded_worker_registry();
+  DCHECK(context());
+  return context()->embedded_worker_registry();
 }
 
 }  // namespace content