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