embedded_worker_test_helper.cc revision 010d83a9304c5a91596085d917d248abff47903a 
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
18static bool AlwaysTrue(int process_id) {
19  return true;
20}
21
22EmbeddedWorkerTestHelper::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
37EmbeddedWorkerTestHelper::~EmbeddedWorkerTestHelper() {
38  if (wrapper_)
39    wrapper_->Shutdown();
40}
41
42void 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
51bool EmbeddedWorkerTestHelper::Send(IPC::Message* message) {
52  OnMessageReceived(*message);
53  delete message;
54  return true;
55}
56
57bool 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
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  // By default just notify the sender that the worker is started.
89  SimulateWorkerStarted(next_thread_id_++, embedded_worker_id);
90}
91
92void 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
97bool 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
114void 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
122void 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
131void 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
143void 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
153void 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
160void EmbeddedWorkerTestHelper::SimulateSend(
161    IPC::Message* message) {
162  registry()->OnMessageReceived(*message);
163  delete message;
164}
165
166void 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
182void 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
192void 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
209void 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
218void 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
229void 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
241EmbeddedWorkerRegistry* EmbeddedWorkerTestHelper::registry() {
242  DCHECK(context());
243  return context()->embedded_worker_registry();
244}
245
246}  // namespace content
247