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