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 "base/bind.h"
   8 #include "content/browser/service_worker/embedded_worker_instance.h"
   9 #include "content/browser/service_worker/embedded_worker_registry.h"
  10 #include "content/browser/service_worker/service_worker_context_core.h"
  11 #include "content/browser/service_worker/service_worker_context_wrapper.h"
  12 #include "content/common/service_worker/embedded_worker_messages.h"
  13 #include "content/common/service_worker/service_worker_messages.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace content {
  17
  18 static bool AlwaysTrue(int process_id) {
  19   return true;
  20 }
  21
  22 EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(int mock_render_process_id)
  23     : wrapper_(new ServiceWorkerContextWrapper(NULL)),
  24       next_thread_id_(0),
  25       weak_factory_(this) {
  26   wrapper_->InitForTesting(base::FilePath(),
  27                            base::MessageLoopProxy::current(),
  28                            NULL);
  29   scoped_ptr<ServiceWorkerProcessManager> process_manager(
  30       new ServiceWorkerProcessManager(wrapper_));
  31   process_manager->SetProcessRefcountOpsForTest(base::Bind(AlwaysTrue),
  32                                                 base::Bind(AlwaysTrue));
  33   wrapper_->context()->SetProcessManagerForTest(process_manager.Pass());
  34   registry()->AddChildProcessSender(mock_render_process_id, this);
  35 }
  36
  37 EmbeddedWorkerTestHelper::~EmbeddedWorkerTestHelper() {
  38   if (wrapper_)
  39     wrapper_->Shutdown();
  40 }
  41
  42 void EmbeddedWorkerTestHelper::SimulateAddProcessToWorker(
  43     int embedded_worker_id,
  44     int process_id) {
  45   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
  46   ASSERT_TRUE(worker);
  47   registry()->AddChildProcessSender(process_id, this);
  48   worker->AddProcessReference(process_id);
  49 }
  50
  51 bool EmbeddedWorkerTestHelper::Send(IPC::Message* message) {
  52   OnMessageReceived(*message);
  53   delete message;
  54   return true;
  55 }
  56
  57 bool EmbeddedWorkerTestHelper::OnMessageReceived(const IPC::Message& message) {
  58   bool handled = true;
  59   IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message)
  60     IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StartWorker, OnStartWorkerStub)
  61     IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StopWorker, OnStopWorkerStub)
  62     IPC_MESSAGE_HANDLER(EmbeddedWorkerContextMsg_MessageToWorker,
  63                         OnMessageToWorkerStub)
  64     IPC_MESSAGE_UNHANDLED(handled = false)
  65   IPC_END_MESSAGE_MAP()
  66
  67   // IPC::TestSink only records messages that are not handled by filters,
  68   // so we just forward all messages to the separate sink.
  69   sink_.OnMessageReceived(message);
  70
  71   return handled;
  72 }
  73
  74 ServiceWorkerContextCore* EmbeddedWorkerTestHelper::context() {
  75   return wrapper_->context();
  76 }
  77
  78 void EmbeddedWorkerTestHelper::ShutdownContext() {
  79   wrapper_->Shutdown();
  80   wrapper_ = NULL;
  81 }
  82
  83 void EmbeddedWorkerTestHelper::OnStartWorker(
  84     int embedded_worker_id,
  85     int64 service_worker_version_id,
  86     const GURL& scope,
  87     const GURL& script_url) {
  88   // By default just notify the sender that the worker is started.
  89   SimulateWorkerStarted(next_thread_id_++, embedded_worker_id);
  90 }
  91
  92 void EmbeddedWorkerTestHelper::OnStopWorker(int embedded_worker_id) {
  93   // By default just notify the sender that the worker is stopped.
  94   SimulateWorkerStopped(embedded_worker_id);
  95 }
  96
  97 bool EmbeddedWorkerTestHelper::OnMessageToWorker(
  98     int thread_id,
  99     int embedded_worker_id,
 100     const IPC::Message& message) {
 101   bool handled = true;
 102   current_embedded_worker_id_ = embedded_worker_id;
 103   IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message)
 104     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEventStub)
 105     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEventStub)
 106     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEventStub)
 107     IPC_MESSAGE_UNHANDLED(handled = false)
 108   IPC_END_MESSAGE_MAP()
 109   // Record all messages directed to inner script context.
 110   inner_sink_.OnMessageReceived(message);
 111   return handled;
 112 }
 113
 114 void EmbeddedWorkerTestHelper::OnActivateEvent(int embedded_worker_id,
 115                                                int request_id) {
 116   SimulateSend(
 117       new ServiceWorkerHostMsg_ActivateEventFinished(
 118           embedded_worker_id, request_id,
 119           blink::WebServiceWorkerEventResultCompleted));
 120 }
 121
 122 void EmbeddedWorkerTestHelper::OnInstallEvent(int embedded_worker_id,
 123                                               int request_id,
 124                                               int active_version_id) {
 125   SimulateSend(
 126       new ServiceWorkerHostMsg_InstallEventFinished(
 127           embedded_worker_id, request_id,
 128           blink::WebServiceWorkerEventResultCompleted));
 129 }
 130
 131 void EmbeddedWorkerTestHelper::OnFetchEvent(
 132     int embedded_worker_id,
 133     int request_id,
 134     const ServiceWorkerFetchRequest& request) {
 135   SimulateSend(
 136       new ServiceWorkerHostMsg_FetchEventFinished(
 137           embedded_worker_id, request_id,
 138           SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
 139           ServiceWorkerResponse(200, "OK", "GET",
 140                                 std::map<std::string, std::string>())));
 141 }
 142
 143 void EmbeddedWorkerTestHelper::SimulateWorkerStarted(
 144     int thread_id, int embedded_worker_id) {
 145   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 146   ASSERT_TRUE(worker != NULL);
 147   registry()->OnWorkerStarted(
 148       worker->process_id(),
 149       thread_id,
 150       embedded_worker_id);
 151 }
 152
 153 void EmbeddedWorkerTestHelper::SimulateWorkerStopped(
 154     int embedded_worker_id) {
 155   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 156   ASSERT_TRUE(worker != NULL);
 157   registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id);
 158 }
 159
 160 void EmbeddedWorkerTestHelper::SimulateSend(
 161     IPC::Message* message) {
 162   registry()->OnMessageReceived(*message);
 163   delete message;
 164 }
 165
 166 void EmbeddedWorkerTestHelper::OnStartWorkerStub(
 167     const EmbeddedWorkerMsg_StartWorker_Params& params) {
 168   EmbeddedWorkerInstance* worker =
 169       registry()->GetWorker(params.embedded_worker_id);
 170   ASSERT_TRUE(worker != NULL);
 171   EXPECT_EQ(EmbeddedWorkerInstance::STARTING, worker->status());
 172   base::MessageLoopProxy::current()->PostTask(
 173       FROM_HERE,
 174       base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker,
 175                  weak_factory_.GetWeakPtr(),
 176                  params.embedded_worker_id,
 177                  params.service_worker_version_id,
 178                  params.scope,
 179                  params.script_url));
 180 }
 181
 182 void EmbeddedWorkerTestHelper::OnStopWorkerStub(int embedded_worker_id) {
 183   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 184   ASSERT_TRUE(worker != NULL);
 185   base::MessageLoopProxy::current()->PostTask(
 186       FROM_HERE,
 187       base::Bind(&EmbeddedWorkerTestHelper::OnStopWorker,
 188                  weak_factory_.GetWeakPtr(),
 189                  embedded_worker_id));
 190 }
 191
 192 void EmbeddedWorkerTestHelper::OnMessageToWorkerStub(
 193     int thread_id,
 194     int embedded_worker_id,
 195     const IPC::Message& message) {
 196   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 197   ASSERT_TRUE(worker != NULL);
 198   EXPECT_EQ(worker->thread_id(), thread_id);
 199   base::MessageLoopProxy::current()->PostTask(
 200       FROM_HERE,
 201       base::Bind(
 202           base::IgnoreResult(&EmbeddedWorkerTestHelper::OnMessageToWorker),
 203           weak_factory_.GetWeakPtr(),
 204           thread_id,
 205           embedded_worker_id,
 206           message));
 207 }
 208
 209 void EmbeddedWorkerTestHelper::OnActivateEventStub(int request_id) {
 210   base::MessageLoopProxy::current()->PostTask(
 211       FROM_HERE,
 212       base::Bind(&EmbeddedWorkerTestHelper::OnActivateEvent,
 213                  weak_factory_.GetWeakPtr(),
 214                  current_embedded_worker_id_,
 215                  request_id));
 216 }
 217
 218 void EmbeddedWorkerTestHelper::OnInstallEventStub(int request_id,
 219                                                   int active_version_id) {
 220   base::MessageLoopProxy::current()->PostTask(
 221       FROM_HERE,
 222       base::Bind(&EmbeddedWorkerTestHelper::OnInstallEvent,
 223                  weak_factory_.GetWeakPtr(),
 224                  current_embedded_worker_id_,
 225                  request_id,
 226                  active_version_id));
 227 }
 228
 229 void EmbeddedWorkerTestHelper::OnFetchEventStub(
 230     int request_id,
 231     const ServiceWorkerFetchRequest& request) {
 232   base::MessageLoopProxy::current()->PostTask(
 233       FROM_HERE,
 234       base::Bind(&EmbeddedWorkerTestHelper::OnFetchEvent,
 235                  weak_factory_.GetWeakPtr(),
 236                  current_embedded_worker_id_,
 237                  request_id,
 238                  request));
 239 }
 240
 241 EmbeddedWorkerRegistry* EmbeddedWorkerTestHelper::registry() {
 242   DCHECK(context());
 243   return context()->embedded_worker_registry();
 244 }
 245
 246 }  // namespace content