src/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   wrapper_->InitInternal(base::FilePath(),
  27                          base::MessageLoopProxy::current(),
  28                          base::MessageLoopProxy::current(),
  29                          base::MessageLoopProxy::current(),
  30                          NULL);
  31   wrapper_->process_manager()->SetProcessIdForTest(mock_render_process_id);
  32   registry()->AddChildProcessSender(mock_render_process_id, this);
  33 }
  34
  35 EmbeddedWorkerTestHelper::~EmbeddedWorkerTestHelper() {
  36   if (wrapper_.get())
  37     wrapper_->Shutdown();
  38 }
  39
  40 void EmbeddedWorkerTestHelper::SimulateAddProcessToPattern(
  41     const GURL& pattern,
  42     int process_id) {
  43   registry()->AddChildProcessSender(process_id, this);
  44   wrapper_->process_manager()->AddProcessReferenceToPattern(
  45       pattern, process_id);
  46 }
  47
  48 bool EmbeddedWorkerTestHelper::Send(IPC::Message* message) {
  49   OnMessageReceived(*message);
  50   delete message;
  51   return true;
  52 }
  53
  54 bool EmbeddedWorkerTestHelper::OnMessageReceived(const IPC::Message& message) {
  55   bool handled = true;
  56   IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message)
  57     IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StartWorker, OnStartWorkerStub)
  58     IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StopWorker, OnStopWorkerStub)
  59     IPC_MESSAGE_HANDLER(EmbeddedWorkerContextMsg_MessageToWorker,
  60                         OnMessageToWorkerStub)
  61     IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_ResumeAfterDownload,
  62                         OnResumeAfterDownloadStub)
  63     IPC_MESSAGE_UNHANDLED(handled = false)
  64   IPC_END_MESSAGE_MAP()
  65
  66   // IPC::TestSink only records messages that are not handled by filters,
  67   // so we just forward all messages to the separate sink.
  68   sink_.OnMessageReceived(message);
  69
  70   return handled;
  71 }
  72
  73 ServiceWorkerContextCore* EmbeddedWorkerTestHelper::context() {
  74   return wrapper_->context();
  75 }
  76
  77 void EmbeddedWorkerTestHelper::ShutdownContext() {
  78   wrapper_->Shutdown();
  79   wrapper_ = NULL;
  80 }
  81
  82 void EmbeddedWorkerTestHelper::OnStartWorker(
  83     int embedded_worker_id,
  84     int64 service_worker_version_id,
  85     const GURL& scope,
  86     const GURL& script_url,
  87     bool pause_after_download) {
  88   if (pause_after_download) {
  89     SimulatePausedAfterDownload(embedded_worker_id);
  90     return;
  91   }
  92   SimulateWorkerReadyForInspection(embedded_worker_id);
  93   SimulateWorkerScriptLoaded(next_thread_id_++, embedded_worker_id);
  94   SimulateWorkerStarted(embedded_worker_id);
  95 }
  96
  97 void EmbeddedWorkerTestHelper::OnResumeAfterDownload(int embedded_worker_id) {
  98   SimulateWorkerReadyForInspection(embedded_worker_id);
  99   SimulateWorkerScriptLoaded(next_thread_id_++, embedded_worker_id);
 100   SimulateWorkerStarted(embedded_worker_id);
 101 }
 102
 103 void EmbeddedWorkerTestHelper::OnStopWorker(int embedded_worker_id) {
 104   // By default just notify the sender that the worker is stopped.
 105   SimulateWorkerStopped(embedded_worker_id);
 106 }
 107
 108 bool EmbeddedWorkerTestHelper::OnMessageToWorker(
 109     int thread_id,
 110     int embedded_worker_id,
 111     const IPC::Message& message) {
 112   bool handled = true;
 113   current_embedded_worker_id_ = embedded_worker_id;
 114   IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message)
 115     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEventStub)
 116     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEventStub)
 117     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEventStub)
 118     IPC_MESSAGE_UNHANDLED(handled = false)
 119   IPC_END_MESSAGE_MAP()
 120   // Record all messages directed to inner script context.
 121   inner_sink_.OnMessageReceived(message);
 122   return handled;
 123 }
 124
 125 void EmbeddedWorkerTestHelper::OnActivateEvent(int embedded_worker_id,
 126                                                int request_id) {
 127   SimulateSend(
 128       new ServiceWorkerHostMsg_ActivateEventFinished(
 129           embedded_worker_id, request_id,
 130           blink::WebServiceWorkerEventResultCompleted));
 131 }
 132
 133 void EmbeddedWorkerTestHelper::OnInstallEvent(int embedded_worker_id,
 134                                               int request_id,
 135                                               int active_version_id) {
 136   SimulateSend(
 137       new ServiceWorkerHostMsg_InstallEventFinished(
 138           embedded_worker_id, request_id,
 139           blink::WebServiceWorkerEventResultCompleted));
 140 }
 141
 142 void EmbeddedWorkerTestHelper::OnFetchEvent(
 143     int embedded_worker_id,
 144     int request_id,
 145     const ServiceWorkerFetchRequest& request) {
 146   SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished(
 147       embedded_worker_id,
 148       request_id,
 149       SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
 150       ServiceWorkerResponse(
 151           GURL(""), 200, "OK", ServiceWorkerHeaderMap(), std::string())));
 152 }
 153
 154 void EmbeddedWorkerTestHelper::SimulatePausedAfterDownload(
 155       int embedded_worker_id) {
 156   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 157   ASSERT_TRUE(worker != NULL);
 158   registry()->OnPausedAfterDownload(worker->process_id(), embedded_worker_id);
 159 }
 160
 161 void EmbeddedWorkerTestHelper::SimulateWorkerReadyForInspection(
 162     int embedded_worker_id) {
 163   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 164   ASSERT_TRUE(worker != NULL);
 165   registry()->OnWorkerReadyForInspection(worker->process_id(),
 166                                          embedded_worker_id);
 167 }
 168
 169 void EmbeddedWorkerTestHelper::SimulateWorkerScriptLoaded(
 170     int thread_id, int embedded_worker_id) {
 171   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 172   ASSERT_TRUE(worker != NULL);
 173   registry()->OnWorkerScriptLoaded(
 174       worker->process_id(), thread_id, embedded_worker_id);
 175 }
 176
 177 void EmbeddedWorkerTestHelper::SimulateWorkerStarted(
 178     int embedded_worker_id) {
 179   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 180   ASSERT_TRUE(worker != NULL);
 181   registry()->OnWorkerStarted(
 182       worker->process_id(),
 183       embedded_worker_id);
 184 }
 185
 186 void EmbeddedWorkerTestHelper::SimulateWorkerStopped(
 187     int embedded_worker_id) {
 188   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 189   if (worker != NULL)
 190     registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id);
 191 }
 192
 193 void EmbeddedWorkerTestHelper::SimulateSend(
 194     IPC::Message* message) {
 195   registry()->OnMessageReceived(*message);
 196   delete message;
 197 }
 198
 199 void EmbeddedWorkerTestHelper::OnStartWorkerStub(
 200     const EmbeddedWorkerMsg_StartWorker_Params& params) {
 201   EmbeddedWorkerInstance* worker =
 202       registry()->GetWorker(params.embedded_worker_id);
 203   ASSERT_TRUE(worker != NULL);
 204   EXPECT_EQ(EmbeddedWorkerInstance::STARTING, worker->status());
 205   base::MessageLoopProxy::current()->PostTask(
 206       FROM_HERE,
 207       base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker,
 208                   weak_factory_.GetWeakPtr(),
 209                   params.embedded_worker_id,
 210                   params.service_worker_version_id,
 211                   params.scope,
 212                   params.script_url,
 213                   params.pause_after_download));
 214 }
 215
 216 void EmbeddedWorkerTestHelper::OnResumeAfterDownloadStub(
 217       int embedded_worker_id) {
 218   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 219   ASSERT_TRUE(worker != NULL);
 220   base::MessageLoopProxy::current()->PostTask(
 221       FROM_HERE,
 222       base::Bind(&EmbeddedWorkerTestHelper::OnResumeAfterDownload,
 223                  weak_factory_.GetWeakPtr(),
 224                  embedded_worker_id));
 225 }
 226
 227 void EmbeddedWorkerTestHelper::OnStopWorkerStub(int embedded_worker_id) {
 228   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 229   ASSERT_TRUE(worker != NULL);
 230   base::MessageLoopProxy::current()->PostTask(
 231       FROM_HERE,
 232       base::Bind(&EmbeddedWorkerTestHelper::OnStopWorker,
 233                  weak_factory_.GetWeakPtr(),
 234                  embedded_worker_id));
 235 }
 236
 237 void EmbeddedWorkerTestHelper::OnMessageToWorkerStub(
 238     int thread_id,
 239     int embedded_worker_id,
 240     const IPC::Message& message) {
 241   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 242   ASSERT_TRUE(worker != NULL);
 243   EXPECT_EQ(worker->thread_id(), thread_id);
 244   base::MessageLoopProxy::current()->PostTask(
 245       FROM_HERE,
 246       base::Bind(
 247           base::IgnoreResult(&EmbeddedWorkerTestHelper::OnMessageToWorker),
 248           weak_factory_.GetWeakPtr(),
 249           thread_id,
 250           embedded_worker_id,
 251           message));
 252 }
 253
 254 void EmbeddedWorkerTestHelper::OnActivateEventStub(int request_id) {
 255   base::MessageLoopProxy::current()->PostTask(
 256       FROM_HERE,
 257       base::Bind(&EmbeddedWorkerTestHelper::OnActivateEvent,
 258                  weak_factory_.GetWeakPtr(),
 259                  current_embedded_worker_id_,
 260                  request_id));
 261 }
 262
 263 void EmbeddedWorkerTestHelper::OnInstallEventStub(int request_id,
 264                                                   int active_version_id) {
 265   base::MessageLoopProxy::current()->PostTask(
 266       FROM_HERE,
 267       base::Bind(&EmbeddedWorkerTestHelper::OnInstallEvent,
 268                  weak_factory_.GetWeakPtr(),
 269                  current_embedded_worker_id_,
 270                  request_id,
 271                  active_version_id));
 272 }
 273
 274 void EmbeddedWorkerTestHelper::OnFetchEventStub(
 275     int request_id,
 276     const ServiceWorkerFetchRequest& request) {
 277   base::MessageLoopProxy::current()->PostTask(
 278       FROM_HERE,
 279       base::Bind(&EmbeddedWorkerTestHelper::OnFetchEvent,
 280                  weak_factory_.GetWeakPtr(),
 281                  current_embedded_worker_id_,
 282                  request_id,
 283                  request));
 284 }
 285
 286 EmbeddedWorkerRegistry* EmbeddedWorkerTestHelper::registry() {
 287   DCHECK(context());
 288   return context()->embedded_worker_registry();
 289 }
 290
 291 }  // namespace content