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