content/browser/service_worker/embedded_worker_test_helper.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/service_worker/embedded_worker_test_helper.h"
   6
   7 #include <map>
   8 #include <string>
   9
  10 #include "base/bind.h"
  11 #include "content/browser/service_worker/embedded_worker_instance.h"
  12 #include "content/browser/service_worker/embedded_worker_registry.h"
  13 #include "content/browser/service_worker/service_worker_context_core.h"
  14 #include "content/browser/service_worker/service_worker_context_wrapper.h"
  15 #include "content/common/service_worker/embedded_worker_messages.h"
  16 #include "content/common/service_worker/service_worker_messages.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace content {
  20
  21 EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(int mock_render_process_id)
  22     : wrapper_(new ServiceWorkerContextWrapper(NULL)),
  23       next_thread_id_(0),
  24       mock_render_process_id_(mock_render_process_id),
  25       weak_factory_(this) {
  26   scoped_ptr<MockServiceWorkerDatabaseTaskManager> database_task_manager(
  27       new MockServiceWorkerDatabaseTaskManager(
  28           base::MessageLoopProxy::current()));
  29   wrapper_->InitInternal(base::FilePath(),
  30                          base::MessageLoopProxy::current(),
  31                          database_task_manager.Pass(),
  32                          base::MessageLoopProxy::current(),
  33                          NULL,
  34                          NULL);
  35   wrapper_->process_manager()->SetProcessIdForTest(mock_render_process_id);
  36   registry()->AddChildProcessSender(mock_render_process_id, this, nullptr);
  37 }
  38
  39 EmbeddedWorkerTestHelper::~EmbeddedWorkerTestHelper() {
  40   if (wrapper_.get())
  41     wrapper_->Shutdown();
  42 }
  43
  44 void EmbeddedWorkerTestHelper::SimulateAddProcessToPattern(
  45     const GURL& pattern,
  46     int process_id) {
  47   registry()->AddChildProcessSender(process_id, this, nullptr);
  48   wrapper_->process_manager()->AddProcessReferenceToPattern(
  49       pattern, process_id);
  50 }
  51
  52 bool EmbeddedWorkerTestHelper::Send(IPC::Message* message) {
  53   OnMessageReceived(*message);
  54   delete message;
  55   return true;
  56 }
  57
  58 bool EmbeddedWorkerTestHelper::OnMessageReceived(const IPC::Message& message) {
  59   bool handled = true;
  60   IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message)
  61     IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StartWorker, OnStartWorkerStub)
  62     IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StopWorker, OnStopWorkerStub)
  63     IPC_MESSAGE_HANDLER(EmbeddedWorkerContextMsg_MessageToWorker,
  64                         OnMessageToWorkerStub)
  65     IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_ResumeAfterDownload,
  66                         OnResumeAfterDownloadStub)
  67     IPC_MESSAGE_UNHANDLED(handled = false)
  68   IPC_END_MESSAGE_MAP()
  69
  70   // IPC::TestSink only records messages that are not handled by filters,
  71   // so we just forward all messages to the separate sink.
  72   sink_.OnMessageReceived(message);
  73
  74   return handled;
  75 }
  76
  77 ServiceWorkerContextCore* EmbeddedWorkerTestHelper::context() {
  78   return wrapper_->context();
  79 }
  80
  81 void EmbeddedWorkerTestHelper::ShutdownContext() {
  82   wrapper_->Shutdown();
  83   wrapper_ = NULL;
  84 }
  85
  86 void EmbeddedWorkerTestHelper::OnStartWorker(
  87     int embedded_worker_id,
  88     int64 service_worker_version_id,
  89     const GURL& scope,
  90     const GURL& script_url,
  91     bool pause_after_download) {
  92   if (pause_after_download) {
  93     SimulatePausedAfterDownload(embedded_worker_id);
  94     return;
  95   }
  96   SimulateWorkerReadyForInspection(embedded_worker_id);
  97   SimulateWorkerScriptLoaded(next_thread_id_++, embedded_worker_id);
  98   SimulateWorkerScriptEvaluated(embedded_worker_id);
  99   SimulateWorkerStarted(embedded_worker_id);
 100 }
 101
 102 void EmbeddedWorkerTestHelper::OnResumeAfterDownload(int embedded_worker_id) {
 103   SimulateWorkerReadyForInspection(embedded_worker_id);
 104   SimulateWorkerScriptLoaded(next_thread_id_++, embedded_worker_id);
 105   SimulateWorkerScriptEvaluated(embedded_worker_id);
 106   SimulateWorkerStarted(embedded_worker_id);
 107 }
 108
 109 void EmbeddedWorkerTestHelper::OnStopWorker(int embedded_worker_id) {
 110   // By default just notify the sender that the worker is stopped.
 111   SimulateWorkerStopped(embedded_worker_id);
 112 }
 113
 114 bool EmbeddedWorkerTestHelper::OnMessageToWorker(
 115     int thread_id,
 116     int embedded_worker_id,
 117     const IPC::Message& message) {
 118   bool handled = true;
 119   current_embedded_worker_id_ = embedded_worker_id;
 120   IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message)
 121     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEventStub)
 122     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEventStub)
 123     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEventStub)
 124     IPC_MESSAGE_UNHANDLED(handled = false)
 125   IPC_END_MESSAGE_MAP()
 126   // Record all messages directed to inner script context.
 127   inner_sink_.OnMessageReceived(message);
 128   return handled;
 129 }
 130
 131 void EmbeddedWorkerTestHelper::OnActivateEvent(int embedded_worker_id,
 132                                                int request_id) {
 133   SimulateSend(
 134       new ServiceWorkerHostMsg_ActivateEventFinished(
 135           embedded_worker_id, request_id,
 136           blink::WebServiceWorkerEventResultCompleted));
 137 }
 138
 139 void EmbeddedWorkerTestHelper::OnInstallEvent(int embedded_worker_id,
 140                                               int request_id) {
 141   // The installing worker may have been doomed and terminated.
 142   if (!registry()->GetWorker(embedded_worker_id))
 143     return;
 144   SimulateSend(
 145       new ServiceWorkerHostMsg_InstallEventFinished(
 146           embedded_worker_id, request_id,
 147           blink::WebServiceWorkerEventResultCompleted));
 148 }
 149
 150 void EmbeddedWorkerTestHelper::OnFetchEvent(
 151     int embedded_worker_id,
 152     int request_id,
 153     const ServiceWorkerFetchRequest& request) {
 154   SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished(
 155       embedded_worker_id,
 156       request_id,
 157       SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
 158       ServiceWorkerResponse(GURL(),
 159                             200,
 160                             "OK",
 161                             blink::WebServiceWorkerResponseTypeDefault,
 162                             ServiceWorkerHeaderMap(),
 163                             std::string(),
 164                             0,
 165                             GURL())));
 166 }
 167
 168 void EmbeddedWorkerTestHelper::SimulatePausedAfterDownload(
 169       int embedded_worker_id) {
 170   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 171   ASSERT_TRUE(worker != NULL);
 172   registry()->OnPausedAfterDownload(worker->process_id(), embedded_worker_id);
 173 }
 174
 175 void EmbeddedWorkerTestHelper::SimulateWorkerReadyForInspection(
 176     int embedded_worker_id) {
 177   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 178   ASSERT_TRUE(worker != NULL);
 179   registry()->OnWorkerReadyForInspection(worker->process_id(),
 180                                          embedded_worker_id);
 181 }
 182
 183 void EmbeddedWorkerTestHelper::SimulateWorkerScriptLoaded(
 184     int thread_id, int embedded_worker_id) {
 185   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 186   ASSERT_TRUE(worker != NULL);
 187   registry()->OnWorkerScriptLoaded(
 188       worker->process_id(), thread_id, embedded_worker_id);
 189 }
 190
 191 void EmbeddedWorkerTestHelper::SimulateWorkerScriptEvaluated(
 192     int embedded_worker_id) {
 193   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 194   ASSERT_TRUE(worker != NULL);
 195   registry()->OnWorkerScriptEvaluated(
 196       worker->process_id(), embedded_worker_id, true /* success */);
 197 }
 198
 199 void EmbeddedWorkerTestHelper::SimulateWorkerStarted(
 200     int embedded_worker_id) {
 201   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 202   ASSERT_TRUE(worker != NULL);
 203   registry()->OnWorkerStarted(
 204       worker->process_id(),
 205       embedded_worker_id);
 206 }
 207
 208 void EmbeddedWorkerTestHelper::SimulateWorkerStopped(
 209     int embedded_worker_id) {
 210   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 211   if (worker != NULL)
 212     registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id);
 213 }
 214
 215 void EmbeddedWorkerTestHelper::SimulateSend(
 216     IPC::Message* message) {
 217   registry()->OnMessageReceived(*message, mock_render_process_id_);
 218   delete message;
 219 }
 220
 221 void EmbeddedWorkerTestHelper::OnStartWorkerStub(
 222     const EmbeddedWorkerMsg_StartWorker_Params& params) {
 223   EmbeddedWorkerInstance* worker =
 224       registry()->GetWorker(params.embedded_worker_id);
 225   ASSERT_TRUE(worker != NULL);
 226   EXPECT_EQ(EmbeddedWorkerInstance::STARTING, worker->status());
 227   base::MessageLoopProxy::current()->PostTask(
 228       FROM_HERE,
 229       base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker,
 230                   weak_factory_.GetWeakPtr(),
 231                   params.embedded_worker_id,
 232                   params.service_worker_version_id,
 233                   params.scope,
 234                   params.script_url,
 235                   params.pause_after_download));
 236 }
 237
 238 void EmbeddedWorkerTestHelper::OnResumeAfterDownloadStub(
 239       int embedded_worker_id) {
 240   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 241   ASSERT_TRUE(worker != NULL);
 242   base::MessageLoopProxy::current()->PostTask(
 243       FROM_HERE,
 244       base::Bind(&EmbeddedWorkerTestHelper::OnResumeAfterDownload,
 245                  weak_factory_.GetWeakPtr(),
 246                  embedded_worker_id));
 247 }
 248
 249 void EmbeddedWorkerTestHelper::OnStopWorkerStub(int embedded_worker_id) {
 250   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 251   ASSERT_TRUE(worker != NULL);
 252   base::MessageLoopProxy::current()->PostTask(
 253       FROM_HERE,
 254       base::Bind(&EmbeddedWorkerTestHelper::OnStopWorker,
 255                  weak_factory_.GetWeakPtr(),
 256                  embedded_worker_id));
 257 }
 258
 259 void EmbeddedWorkerTestHelper::OnMessageToWorkerStub(
 260     int thread_id,
 261     int embedded_worker_id,
 262     const IPC::Message& message) {
 263   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 264   ASSERT_TRUE(worker != NULL);
 265   EXPECT_EQ(worker->thread_id(), thread_id);
 266   base::MessageLoopProxy::current()->PostTask(
 267       FROM_HERE,
 268       base::Bind(
 269           base::IgnoreResult(&EmbeddedWorkerTestHelper::OnMessageToWorker),
 270           weak_factory_.GetWeakPtr(),
 271           thread_id,
 272           embedded_worker_id,
 273           message));
 274 }
 275
 276 void EmbeddedWorkerTestHelper::OnActivateEventStub(int request_id) {
 277   base::MessageLoopProxy::current()->PostTask(
 278       FROM_HERE,
 279       base::Bind(&EmbeddedWorkerTestHelper::OnActivateEvent,
 280                  weak_factory_.GetWeakPtr(),
 281                  current_embedded_worker_id_,
 282                  request_id));
 283 }
 284
 285 void EmbeddedWorkerTestHelper::OnInstallEventStub(int request_id) {
 286   base::MessageLoopProxy::current()->PostTask(
 287       FROM_HERE,
 288       base::Bind(&EmbeddedWorkerTestHelper::OnInstallEvent,
 289                  weak_factory_.GetWeakPtr(),
 290                  current_embedded_worker_id_,
 291                  request_id));
 292 }
 293
 294 void EmbeddedWorkerTestHelper::OnFetchEventStub(
 295     int request_id,
 296     const ServiceWorkerFetchRequest& request) {
 297   base::MessageLoopProxy::current()->PostTask(
 298       FROM_HERE,
 299       base::Bind(&EmbeddedWorkerTestHelper::OnFetchEvent,
 300                  weak_factory_.GetWeakPtr(),
 301                  current_embedded_worker_id_,
 302                  request_id,
 303                  request));
 304 }
 305
 306 EmbeddedWorkerRegistry* EmbeddedWorkerTestHelper::registry() {
 307   DCHECK(context());
 308   return context()->embedded_worker_registry();
 309 }
 310
 311 }  // namespace content