OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/service_worker/embedded_worker_instance.h" | 5 #include "content/browser/service_worker/embedded_worker_instance.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 #include <utility> | 8 #include <utility> |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
11 #include "base/command_line.h" | 11 #include "base/command_line.h" |
12 #include "base/macros.h" | 12 #include "base/macros.h" |
13 #include "base/run_loop.h" | 13 #include "base/run_loop.h" |
14 #include "base/stl_util.h" | 14 #include "base/stl_util.h" |
15 #include "content/browser/service_worker/embedded_worker_registry.h" | 15 #include "content/browser/service_worker/embedded_worker_registry.h" |
16 #include "content/browser/service_worker/embedded_worker_status.h" | 16 #include "content/browser/service_worker/embedded_worker_status.h" |
17 #include "content/browser/service_worker/embedded_worker_test_helper.h" | 17 #include "content/browser/service_worker/embedded_worker_test_helper.h" |
18 #include "content/browser/service_worker/service_worker_context_core.h" | 18 #include "content/browser/service_worker/service_worker_context_core.h" |
19 #include "content/browser/service_worker/service_worker_context_wrapper.h" | 19 #include "content/browser/service_worker/service_worker_context_wrapper.h" |
20 #include "content/browser/service_worker/service_worker_test_utils.h" | 20 #include "content/browser/service_worker/service_worker_test_utils.h" |
21 #include "content/common/service_worker/embedded_worker.mojom.h" | 21 #include "content/common/service_worker/embedded_worker.mojom.h" |
22 #include "content/common/service_worker/embedded_worker_messages.h" | 22 #include "content/common/service_worker/embedded_worker_messages.h" |
23 #include "content/common/service_worker/embedded_worker_start_params.h" | 23 #include "content/common/service_worker/embedded_worker_start_params.h" |
| 24 #include "content/common/service_worker/service_worker_event_dispatcher.mojom.h" |
24 #include "content/common/service_worker/service_worker_utils.h" | 25 #include "content/common/service_worker/service_worker_utils.h" |
25 #include "content/public/common/child_process_host.h" | 26 #include "content/public/common/child_process_host.h" |
26 #include "content/public/common/content_switches.h" | 27 #include "content/public/common/content_switches.h" |
27 #include "content/public/test/test_browser_thread_bundle.h" | 28 #include "content/public/test/test_browser_thread_bundle.h" |
28 #include "mojo/public/cpp/bindings/strong_binding.h" | 29 #include "mojo/public/cpp/bindings/strong_binding.h" |
29 #include "testing/gmock/include/gmock/gmock.h" | 30 #include "testing/gmock/include/gmock/gmock.h" |
30 #include "testing/gtest/include/gtest/gtest.h" | 31 #include "testing/gtest/include/gtest/gtest.h" |
31 | 32 |
32 namespace content { | 33 namespace content { |
33 | 34 |
34 namespace { | 35 namespace { |
35 | 36 |
36 void SaveStatusAndCall(ServiceWorkerStatusCode* out, | 37 void SaveStatusAndCall(ServiceWorkerStatusCode* out, |
37 const base::Closure& callback, | 38 const base::Closure& callback, |
38 ServiceWorkerStatusCode status) { | 39 ServiceWorkerStatusCode status) { |
39 *out = status; | 40 *out = status; |
40 callback.Run(); | 41 callback.Run(); |
41 } | 42 } |
42 | 43 |
43 std::unique_ptr<EmbeddedWorkerStartParams> | |
44 CreateStartParams(int version_id, const GURL& scope, const GURL& script_url) { | |
45 std::unique_ptr<EmbeddedWorkerStartParams> params( | |
46 new EmbeddedWorkerStartParams); | |
47 params->service_worker_version_id = version_id; | |
48 params->scope = scope; | |
49 params->script_url = script_url; | |
50 params->pause_after_download = false; | |
51 params->is_installed = false; | |
52 return params; | |
53 } | |
54 | |
55 } // namespace | 44 } // namespace |
56 | 45 |
57 class EmbeddedWorkerInstanceTest : public testing::Test, | 46 class EmbeddedWorkerInstanceTest : public testing::Test, |
58 public EmbeddedWorkerInstance::Listener { | 47 public EmbeddedWorkerInstance::Listener { |
59 protected: | 48 protected: |
60 EmbeddedWorkerInstanceTest() | 49 EmbeddedWorkerInstanceTest() |
61 : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} | 50 : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} |
62 | 51 |
63 enum EventType { | 52 enum EventType { |
64 PROCESS_ALLOCATED, | 53 PROCESS_ALLOCATED, |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
100 | 89 |
101 void TearDown() override { helper_.reset(); } | 90 void TearDown() override { helper_.reset(); } |
102 | 91 |
103 ServiceWorkerStatusCode StartWorker(EmbeddedWorkerInstance* worker, | 92 ServiceWorkerStatusCode StartWorker(EmbeddedWorkerInstance* worker, |
104 int id, const GURL& pattern, | 93 int id, const GURL& pattern, |
105 const GURL& url) { | 94 const GURL& url) { |
106 ServiceWorkerStatusCode status; | 95 ServiceWorkerStatusCode status; |
107 base::RunLoop run_loop; | 96 base::RunLoop run_loop; |
108 std::unique_ptr<EmbeddedWorkerStartParams> params = | 97 std::unique_ptr<EmbeddedWorkerStartParams> params = |
109 CreateStartParams(id, pattern, url); | 98 CreateStartParams(id, pattern, url); |
110 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 99 worker->Start( |
111 run_loop.QuitClosure())); | 100 std::move(params), CreateEventDispatcher(), |
| 101 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
112 run_loop.Run(); | 102 run_loop.Run(); |
113 return status; | 103 return status; |
114 } | 104 } |
115 | 105 |
| 106 std::unique_ptr<EmbeddedWorkerStartParams> |
| 107 CreateStartParams(int version_id, const GURL& scope, const GURL& script_url) { |
| 108 std::unique_ptr<EmbeddedWorkerStartParams> params = |
| 109 base::MakeUnique<EmbeddedWorkerStartParams>(); |
| 110 params->service_worker_version_id = version_id; |
| 111 params->scope = scope; |
| 112 params->script_url = script_url; |
| 113 params->pause_after_download = false; |
| 114 params->is_installed = false; |
| 115 return params; |
| 116 } |
| 117 |
| 118 mojom::ServiceWorkerEventDispatcherRequest CreateEventDispatcher() { |
| 119 dispatchers_.emplace_back(); |
| 120 return mojo::GetProxy(&dispatchers_.back()); |
| 121 } |
| 122 |
116 ServiceWorkerContextCore* context() { return helper_->context(); } | 123 ServiceWorkerContextCore* context() { return helper_->context(); } |
117 | 124 |
118 EmbeddedWorkerRegistry* embedded_worker_registry() { | 125 EmbeddedWorkerRegistry* embedded_worker_registry() { |
119 DCHECK(context()); | 126 DCHECK(context()); |
120 return context()->embedded_worker_registry(); | 127 return context()->embedded_worker_registry(); |
121 } | 128 } |
122 | 129 |
123 IPC::TestSink* ipc_sink() { return helper_->ipc_sink(); } | 130 IPC::TestSink* ipc_sink() { return helper_->ipc_sink(); } |
124 | 131 |
125 std::vector<std::unique_ptr< | 132 std::vector<std::unique_ptr< |
126 EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient>>* | 133 EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient>>* |
127 mock_instance_clients() { | 134 mock_instance_clients() { |
128 return helper_->mock_instance_clients(); | 135 return helper_->mock_instance_clients(); |
129 } | 136 } |
130 | 137 |
| 138 std::vector<mojom::ServiceWorkerEventDispatcherPtr> dispatchers_; |
| 139 |
131 TestBrowserThreadBundle thread_bundle_; | 140 TestBrowserThreadBundle thread_bundle_; |
132 std::unique_ptr<EmbeddedWorkerTestHelper> helper_; | 141 std::unique_ptr<EmbeddedWorkerTestHelper> helper_; |
133 std::vector<EventLog> events_; | 142 std::vector<EventLog> events_; |
134 | 143 |
135 private: | 144 private: |
136 DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerInstanceTest); | 145 DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerInstanceTest); |
137 }; | 146 }; |
138 | 147 |
139 class EmbeddedWorkerInstanceTestP | 148 class EmbeddedWorkerInstanceTestP |
140 : public MojoServiceWorkerTestP<EmbeddedWorkerInstanceTest> {}; | 149 : public MojoServiceWorkerTestP<EmbeddedWorkerInstanceTest> {}; |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
191 | 200 |
192 // Simulate adding one process to the pattern. | 201 // Simulate adding one process to the pattern. |
193 helper_->SimulateAddProcessToPattern(pattern, | 202 helper_->SimulateAddProcessToPattern(pattern, |
194 helper_->mock_render_process_id()); | 203 helper_->mock_render_process_id()); |
195 | 204 |
196 // Start should succeed. | 205 // Start should succeed. |
197 ServiceWorkerStatusCode status; | 206 ServiceWorkerStatusCode status; |
198 base::RunLoop run_loop; | 207 base::RunLoop run_loop; |
199 std::unique_ptr<EmbeddedWorkerStartParams> params = | 208 std::unique_ptr<EmbeddedWorkerStartParams> params = |
200 CreateStartParams(service_worker_version_id, pattern, url); | 209 CreateStartParams(service_worker_version_id, pattern, url); |
201 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 210 worker->Start( |
202 run_loop.QuitClosure())); | 211 std::move(params), CreateEventDispatcher(), |
| 212 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
203 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); | 213 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); |
204 run_loop.Run(); | 214 run_loop.Run(); |
205 EXPECT_EQ(SERVICE_WORKER_OK, status); | 215 EXPECT_EQ(SERVICE_WORKER_OK, status); |
206 | 216 |
207 // The 'WorkerStarted' message should have been sent by | 217 // The 'WorkerStarted' message should have been sent by |
208 // EmbeddedWorkerTestHelper. | 218 // EmbeddedWorkerTestHelper. |
209 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); | 219 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); |
210 EXPECT_EQ(helper_->mock_render_process_id(), worker->process_id()); | 220 EXPECT_EQ(helper_->mock_render_process_id(), worker->process_id()); |
211 | 221 |
212 // Stop the worker. | 222 // Stop the worker. |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
254 // unittests can't actually create a new process itself. | 264 // unittests can't actually create a new process itself. |
255 // ServiceWorkerProcessManager only chooses this process id in unittests if | 265 // ServiceWorkerProcessManager only chooses this process id in unittests if |
256 // can_use_existing_process is false. | 266 // can_use_existing_process is false. |
257 helper_->SimulateAddProcessToPattern(pattern, | 267 helper_->SimulateAddProcessToPattern(pattern, |
258 helper_->new_render_process_id()); | 268 helper_->new_render_process_id()); |
259 | 269 |
260 { | 270 { |
261 // Start once normally. | 271 // Start once normally. |
262 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 272 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
263 base::RunLoop run_loop; | 273 base::RunLoop run_loop; |
264 std::unique_ptr<EmbeddedWorkerStartParams> params( | 274 std::unique_ptr<EmbeddedWorkerStartParams> params = |
265 CreateStartParams(service_worker_version_id, pattern, url)); | 275 CreateStartParams(service_worker_version_id, pattern, url); |
266 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 276 worker->Start( |
267 run_loop.QuitClosure())); | 277 std::move(params), CreateEventDispatcher(), |
| 278 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
268 run_loop.Run(); | 279 run_loop.Run(); |
269 EXPECT_EQ(SERVICE_WORKER_OK, status); | 280 EXPECT_EQ(SERVICE_WORKER_OK, status); |
270 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); | 281 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); |
271 // The worker should be using the default render process. | 282 // The worker should be using the default render process. |
272 EXPECT_EQ(helper_->mock_render_process_id(), worker->process_id()); | 283 EXPECT_EQ(helper_->mock_render_process_id(), worker->process_id()); |
273 | 284 |
274 EXPECT_EQ(SERVICE_WORKER_OK, worker->Stop()); | 285 EXPECT_EQ(SERVICE_WORKER_OK, worker->Stop()); |
275 base::RunLoop().RunUntilIdle(); | 286 base::RunLoop().RunUntilIdle(); |
276 } | 287 } |
277 | 288 |
278 // Fail twice. | 289 // Fail twice. |
279 context()->UpdateVersionFailureCount(service_worker_version_id, | 290 context()->UpdateVersionFailureCount(service_worker_version_id, |
280 SERVICE_WORKER_ERROR_FAILED); | 291 SERVICE_WORKER_ERROR_FAILED); |
281 context()->UpdateVersionFailureCount(service_worker_version_id, | 292 context()->UpdateVersionFailureCount(service_worker_version_id, |
282 SERVICE_WORKER_ERROR_FAILED); | 293 SERVICE_WORKER_ERROR_FAILED); |
283 | 294 |
284 { | 295 { |
285 // Start again. | 296 // Start again. |
286 ServiceWorkerStatusCode status; | 297 ServiceWorkerStatusCode status; |
287 base::RunLoop run_loop; | 298 base::RunLoop run_loop; |
288 std::unique_ptr<EmbeddedWorkerStartParams> params( | 299 std::unique_ptr<EmbeddedWorkerStartParams> params = |
289 CreateStartParams(service_worker_version_id, pattern, url)); | 300 CreateStartParams(service_worker_version_id, pattern, url); |
290 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 301 worker->Start( |
291 run_loop.QuitClosure())); | 302 std::move(params), CreateEventDispatcher(), |
| 303 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
292 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); | 304 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); |
293 run_loop.Run(); | 305 run_loop.Run(); |
294 EXPECT_EQ(SERVICE_WORKER_OK, status); | 306 EXPECT_EQ(SERVICE_WORKER_OK, status); |
295 | 307 |
296 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); | 308 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); |
297 // The worker should be using the new render process. | 309 // The worker should be using the new render process. |
298 EXPECT_EQ(helper_->new_render_process_id(), worker->process_id()); | 310 EXPECT_EQ(helper_->new_render_process_id(), worker->process_id()); |
299 EXPECT_EQ(SERVICE_WORKER_OK, worker->Stop()); | 311 EXPECT_EQ(SERVICE_WORKER_OK, worker->Stop()); |
300 base::RunLoop().RunUntilIdle(); | 312 base::RunLoop().RunUntilIdle(); |
301 } | 313 } |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
358 const int64_t version_id2 = 56L; | 370 const int64_t version_id2 = 56L; |
359 const GURL pattern("http://example.com/"); | 371 const GURL pattern("http://example.com/"); |
360 const GURL url("http://example.com/worker.js"); | 372 const GURL url("http://example.com/worker.js"); |
361 int process_id = helper_->mock_render_process_id(); | 373 int process_id = helper_->mock_render_process_id(); |
362 | 374 |
363 helper_->SimulateAddProcessToPattern(pattern, process_id); | 375 helper_->SimulateAddProcessToPattern(pattern, process_id); |
364 { | 376 { |
365 // Start worker1. | 377 // Start worker1. |
366 ServiceWorkerStatusCode status; | 378 ServiceWorkerStatusCode status; |
367 base::RunLoop run_loop; | 379 base::RunLoop run_loop; |
368 std::unique_ptr<EmbeddedWorkerStartParams> params( | 380 std::unique_ptr<EmbeddedWorkerStartParams> params = |
369 CreateStartParams(version_id1, pattern, url)); | 381 CreateStartParams(version_id1, pattern, url); |
370 worker1->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 382 worker1->Start( |
371 run_loop.QuitClosure())); | 383 std::move(params), CreateEventDispatcher(), |
| 384 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
372 run_loop.Run(); | 385 run_loop.Run(); |
373 EXPECT_EQ(SERVICE_WORKER_OK, status); | 386 EXPECT_EQ(SERVICE_WORKER_OK, status); |
374 } | 387 } |
375 | 388 |
376 { | 389 { |
377 // Start worker2. | 390 // Start worker2. |
378 ServiceWorkerStatusCode status; | 391 ServiceWorkerStatusCode status; |
379 base::RunLoop run_loop; | 392 base::RunLoop run_loop; |
380 std::unique_ptr<EmbeddedWorkerStartParams> params( | 393 std::unique_ptr<EmbeddedWorkerStartParams> params = |
381 CreateStartParams(version_id2, pattern, url)); | 394 CreateStartParams(version_id2, pattern, url); |
382 worker2->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 395 worker2->Start( |
383 run_loop.QuitClosure())); | 396 std::move(params), CreateEventDispatcher(), |
| 397 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
384 run_loop.Run(); | 398 run_loop.Run(); |
385 EXPECT_EQ(SERVICE_WORKER_OK, status); | 399 EXPECT_EQ(SERVICE_WORKER_OK, status); |
386 } | 400 } |
387 | 401 |
388 // The two workers share the same process. | 402 // The two workers share the same process. |
389 EXPECT_EQ(worker1->process_id(), worker2->process_id()); | 403 EXPECT_EQ(worker1->process_id(), worker2->process_id()); |
390 | 404 |
391 // Destroy worker1. It removes itself from the registry. | 405 // Destroy worker1. It removes itself from the registry. |
392 int worker1_id = worker1->embedded_worker_id(); | 406 int worker1_id = worker1->embedded_worker_id(); |
393 worker1->Stop(); | 407 worker1->Stop(); |
(...skipping 13 matching lines...) Expand all Loading... |
407 const int64_t version_id = 55L; | 421 const int64_t version_id = 55L; |
408 const GURL scope("http://example.com/"); | 422 const GURL scope("http://example.com/"); |
409 const GURL url("http://example.com/worker.js"); | 423 const GURL url("http://example.com/worker.js"); |
410 | 424 |
411 std::unique_ptr<EmbeddedWorkerInstance> worker = | 425 std::unique_ptr<EmbeddedWorkerInstance> worker = |
412 embedded_worker_registry()->CreateWorker(); | 426 embedded_worker_registry()->CreateWorker(); |
413 worker->AddListener(this); | 427 worker->AddListener(this); |
414 | 428 |
415 // Run the start worker sequence and detach during process allocation. | 429 // Run the start worker sequence and detach during process allocation. |
416 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 430 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
417 std::unique_ptr<EmbeddedWorkerStartParams> params( | 431 std::unique_ptr<EmbeddedWorkerStartParams> params = |
418 CreateStartParams(version_id, scope, url)); | 432 CreateStartParams(version_id, scope, url); |
419 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 433 worker->Start( |
420 base::Bind(&base::DoNothing))); | 434 std::move(params), CreateEventDispatcher(), |
| 435 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); |
421 worker->Detach(); | 436 worker->Detach(); |
422 base::RunLoop().RunUntilIdle(); | 437 base::RunLoop().RunUntilIdle(); |
423 | 438 |
424 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); | 439 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); |
425 EXPECT_EQ(ChildProcessHost::kInvalidUniqueID, worker->process_id()); | 440 EXPECT_EQ(ChildProcessHost::kInvalidUniqueID, worker->process_id()); |
426 | 441 |
427 // The start callback should not be aborted by detach (see a comment on the | 442 // The start callback should not be aborted by detach (see a comment on the |
428 // dtor of EmbeddedWorkerInstance::StartTask). | 443 // dtor of EmbeddedWorkerInstance::StartTask). |
429 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); | 444 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); |
430 | 445 |
431 // "PROCESS_ALLOCATED" event should not be recorded. | 446 // "PROCESS_ALLOCATED" event should not be recorded. |
432 ASSERT_EQ(1u, events_.size()); | 447 ASSERT_EQ(1u, events_.size()); |
433 EXPECT_EQ(DETACHED, events_[0].type); | 448 EXPECT_EQ(DETACHED, events_[0].type); |
434 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[0].status); | 449 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[0].status); |
435 } | 450 } |
436 | 451 |
437 TEST_P(EmbeddedWorkerInstanceTestP, DetachAfterSendingStartWorkerMessage) { | 452 TEST_P(EmbeddedWorkerInstanceTestP, DetachAfterSendingStartWorkerMessage) { |
438 const int64_t version_id = 55L; | 453 const int64_t version_id = 55L; |
439 const GURL scope("http://example.com/"); | 454 const GURL scope("http://example.com/"); |
440 const GURL url("http://example.com/worker.js"); | 455 const GURL url("http://example.com/worker.js"); |
441 | 456 |
442 helper_.reset(new StalledInStartWorkerHelper()); | 457 helper_.reset(new StalledInStartWorkerHelper()); |
443 std::unique_ptr<EmbeddedWorkerInstance> worker = | 458 std::unique_ptr<EmbeddedWorkerInstance> worker = |
444 embedded_worker_registry()->CreateWorker(); | 459 embedded_worker_registry()->CreateWorker(); |
445 worker->AddListener(this); | 460 worker->AddListener(this); |
446 | 461 |
447 // Run the start worker sequence until a start worker message is sent. | 462 // Run the start worker sequence until a start worker message is sent. |
448 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 463 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
449 std::unique_ptr<EmbeddedWorkerStartParams> params( | 464 std::unique_ptr<EmbeddedWorkerStartParams> params = |
450 CreateStartParams(version_id, scope, url)); | 465 CreateStartParams(version_id, scope, url); |
451 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 466 worker->Start( |
452 base::Bind(&base::DoNothing))); | 467 std::move(params), CreateEventDispatcher(), |
| 468 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); |
453 base::RunLoop().RunUntilIdle(); | 469 base::RunLoop().RunUntilIdle(); |
454 | 470 |
455 ASSERT_EQ(2u, events_.size()); | 471 ASSERT_EQ(2u, events_.size()); |
456 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 472 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
457 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 473 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
458 events_.clear(); | 474 events_.clear(); |
459 | 475 |
460 worker->Detach(); | 476 worker->Detach(); |
461 base::RunLoop().RunUntilIdle(); | 477 base::RunLoop().RunUntilIdle(); |
462 | 478 |
(...skipping 15 matching lines...) Expand all Loading... |
478 const GURL scope("http://example.com/"); | 494 const GURL scope("http://example.com/"); |
479 const GURL url("http://example.com/worker.js"); | 495 const GURL url("http://example.com/worker.js"); |
480 | 496 |
481 std::unique_ptr<EmbeddedWorkerInstance> worker = | 497 std::unique_ptr<EmbeddedWorkerInstance> worker = |
482 embedded_worker_registry()->CreateWorker(); | 498 embedded_worker_registry()->CreateWorker(); |
483 worker->AddListener(this); | 499 worker->AddListener(this); |
484 | 500 |
485 // Stop the start worker sequence before a process is allocated. | 501 // Stop the start worker sequence before a process is allocated. |
486 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 502 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
487 | 503 |
488 std::unique_ptr<EmbeddedWorkerStartParams> params( | 504 std::unique_ptr<EmbeddedWorkerStartParams> params = |
489 CreateStartParams(version_id, scope, url)); | 505 CreateStartParams(version_id, scope, url); |
490 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 506 worker->Start( |
491 base::Bind(&base::DoNothing))); | 507 std::move(params), CreateEventDispatcher(), |
| 508 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); |
492 worker->Stop(); | 509 worker->Stop(); |
493 base::RunLoop().RunUntilIdle(); | 510 base::RunLoop().RunUntilIdle(); |
494 | 511 |
495 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); | 512 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); |
496 EXPECT_EQ(ChildProcessHost::kInvalidUniqueID, worker->process_id()); | 513 EXPECT_EQ(ChildProcessHost::kInvalidUniqueID, worker->process_id()); |
497 | 514 |
498 // The start callback should not be aborted by stop (see a comment on the dtor | 515 // The start callback should not be aborted by stop (see a comment on the dtor |
499 // of EmbeddedWorkerInstance::StartTask). | 516 // of EmbeddedWorkerInstance::StartTask). |
500 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); | 517 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); |
501 | 518 |
502 // "PROCESS_ALLOCATED" event should not be recorded. | 519 // "PROCESS_ALLOCATED" event should not be recorded. |
503 ASSERT_EQ(1u, events_.size()); | 520 ASSERT_EQ(1u, events_.size()); |
504 EXPECT_EQ(DETACHED, events_[0].type); | 521 EXPECT_EQ(DETACHED, events_[0].type); |
505 if (is_mojo_enabled()) { | 522 if (is_mojo_enabled()) { |
506 // STOPPING should be recorded here because EmbeddedWorkerInstance must be | 523 // STOPPING should be recorded here because EmbeddedWorkerInstance must be |
507 // detached while executing RunUntilIdle. | 524 // detached while executing RunUntilIdle. |
508 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, events_[0].status); | 525 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, events_[0].status); |
509 } else { | 526 } else { |
510 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[0].status); | 527 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[0].status); |
511 } | 528 } |
512 events_.clear(); | 529 events_.clear(); |
513 | 530 |
514 // Restart the worker. | 531 // Restart the worker. |
515 status = SERVICE_WORKER_ERROR_MAX_VALUE; | 532 status = SERVICE_WORKER_ERROR_MAX_VALUE; |
516 std::unique_ptr<base::RunLoop> run_loop(new base::RunLoop); | 533 std::unique_ptr<base::RunLoop> run_loop(new base::RunLoop); |
517 params = CreateStartParams(version_id, scope, url); | 534 params = CreateStartParams(version_id, scope, url); |
518 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 535 worker->Start( |
519 run_loop->QuitClosure())); | 536 std::move(params), CreateEventDispatcher(), |
| 537 base::Bind(&SaveStatusAndCall, &status, run_loop->QuitClosure())); |
520 run_loop->Run(); | 538 run_loop->Run(); |
521 | 539 |
522 EXPECT_EQ(SERVICE_WORKER_OK, status); | 540 EXPECT_EQ(SERVICE_WORKER_OK, status); |
523 ASSERT_EQ(3u, events_.size()); | 541 ASSERT_EQ(3u, events_.size()); |
524 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 542 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
525 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 543 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
526 EXPECT_EQ(STARTED, events_[2].type); | 544 EXPECT_EQ(STARTED, events_[2].type); |
527 | 545 |
528 // Tear down the worker. | 546 // Tear down the worker. |
529 worker->Stop(); | 547 worker->Stop(); |
530 } | 548 } |
531 | 549 |
532 TEST_P(EmbeddedWorkerInstanceTestP, StopDuringPausedAfterDownload) { | 550 TEST_P(EmbeddedWorkerInstanceTestP, StopDuringPausedAfterDownload) { |
533 const int64_t version_id = 55L; | 551 const int64_t version_id = 55L; |
534 const GURL scope("http://example.com/"); | 552 const GURL scope("http://example.com/"); |
535 const GURL url("http://example.com/worker.js"); | 553 const GURL url("http://example.com/worker.js"); |
536 | 554 |
537 std::unique_ptr<EmbeddedWorkerInstance> worker = | 555 std::unique_ptr<EmbeddedWorkerInstance> worker = |
538 embedded_worker_registry()->CreateWorker(); | 556 embedded_worker_registry()->CreateWorker(); |
539 worker->AddListener(this); | 557 worker->AddListener(this); |
540 | 558 |
541 // Run the start worker sequence until pause after download. | 559 // Run the start worker sequence until pause after download. |
542 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 560 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
543 | 561 |
544 std::unique_ptr<EmbeddedWorkerStartParams> params( | 562 std::unique_ptr<EmbeddedWorkerStartParams> params = |
545 CreateStartParams(version_id, scope, url)); | 563 CreateStartParams(version_id, scope, url); |
546 params->pause_after_download = true; | 564 params->pause_after_download = true; |
547 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 565 worker->Start( |
548 base::Bind(&base::DoNothing))); | 566 std::move(params), CreateEventDispatcher(), |
| 567 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); |
549 base::RunLoop().RunUntilIdle(); | 568 base::RunLoop().RunUntilIdle(); |
550 | 569 |
551 // Make the worker stopping and attempt to send a resume after download | 570 // Make the worker stopping and attempt to send a resume after download |
552 // message. | 571 // message. |
553 worker->Stop(); | 572 worker->Stop(); |
554 worker->ResumeAfterDownload(); | 573 worker->ResumeAfterDownload(); |
555 base::RunLoop().RunUntilIdle(); | 574 base::RunLoop().RunUntilIdle(); |
556 | 575 |
557 // The resume after download message should not have been sent. | 576 // The resume after download message should not have been sent. |
558 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); | 577 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); |
559 EXPECT_FALSE(ipc_sink()->GetFirstMessageMatching( | 578 EXPECT_FALSE(ipc_sink()->GetFirstMessageMatching( |
560 EmbeddedWorkerMsg_ResumeAfterDownload::ID)); | 579 EmbeddedWorkerMsg_ResumeAfterDownload::ID)); |
561 } | 580 } |
562 | 581 |
563 TEST_P(EmbeddedWorkerInstanceTestP, StopAfterSendingStartWorkerMessage) { | 582 TEST_P(EmbeddedWorkerInstanceTestP, StopAfterSendingStartWorkerMessage) { |
564 const int64_t version_id = 55L; | 583 const int64_t version_id = 55L; |
565 const GURL scope("http://example.com/"); | 584 const GURL scope("http://example.com/"); |
566 const GURL url("http://example.com/worker.js"); | 585 const GURL url("http://example.com/worker.js"); |
567 | 586 |
568 helper_.reset(new StalledInStartWorkerHelper); | 587 helper_.reset(new StalledInStartWorkerHelper); |
569 std::unique_ptr<EmbeddedWorkerInstance> worker = | 588 std::unique_ptr<EmbeddedWorkerInstance> worker = |
570 embedded_worker_registry()->CreateWorker(); | 589 embedded_worker_registry()->CreateWorker(); |
571 worker->AddListener(this); | 590 worker->AddListener(this); |
572 | 591 |
573 // Run the start worker sequence until a start worker message is sent. | 592 // Run the start worker sequence until a start worker message is sent. |
574 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 593 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
575 std::unique_ptr<EmbeddedWorkerStartParams> params( | 594 std::unique_ptr<EmbeddedWorkerStartParams> params = |
576 CreateStartParams(version_id, scope, url)); | 595 CreateStartParams(version_id, scope, url); |
577 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 596 worker->Start( |
578 base::Bind(&base::DoNothing))); | 597 std::move(params), CreateEventDispatcher(), |
| 598 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); |
579 base::RunLoop().RunUntilIdle(); | 599 base::RunLoop().RunUntilIdle(); |
580 | 600 |
581 ASSERT_EQ(2u, events_.size()); | 601 ASSERT_EQ(2u, events_.size()); |
582 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 602 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
583 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 603 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
584 events_.clear(); | 604 events_.clear(); |
585 | 605 |
586 worker->Stop(); | 606 worker->Stop(); |
587 base::RunLoop().RunUntilIdle(); | 607 base::RunLoop().RunUntilIdle(); |
588 | 608 |
(...skipping 10 matching lines...) Expand all Loading... |
599 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, events_[0].status); | 619 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, events_[0].status); |
600 events_.clear(); | 620 events_.clear(); |
601 | 621 |
602 // Restart the worker. | 622 // Restart the worker. |
603 static_cast<StalledInStartWorkerHelper*>(helper_.get()) | 623 static_cast<StalledInStartWorkerHelper*>(helper_.get()) |
604 ->set_force_stall_in_start(false); | 624 ->set_force_stall_in_start(false); |
605 status = SERVICE_WORKER_ERROR_MAX_VALUE; | 625 status = SERVICE_WORKER_ERROR_MAX_VALUE; |
606 std::unique_ptr<base::RunLoop> run_loop(new base::RunLoop); | 626 std::unique_ptr<base::RunLoop> run_loop(new base::RunLoop); |
607 | 627 |
608 params = CreateStartParams(version_id, scope, url); | 628 params = CreateStartParams(version_id, scope, url); |
609 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 629 worker->Start( |
610 run_loop->QuitClosure())); | 630 std::move(params), CreateEventDispatcher(), |
| 631 base::Bind(&SaveStatusAndCall, &status, run_loop->QuitClosure())); |
611 run_loop->Run(); | 632 run_loop->Run(); |
612 | 633 |
613 // The worker should be started. | 634 // The worker should be started. |
614 EXPECT_EQ(SERVICE_WORKER_OK, status); | 635 EXPECT_EQ(SERVICE_WORKER_OK, status); |
615 ASSERT_EQ(3u, events_.size()); | 636 ASSERT_EQ(3u, events_.size()); |
616 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 637 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
617 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 638 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
618 EXPECT_EQ(STARTED, events_[2].type); | 639 EXPECT_EQ(STARTED, events_[2].type); |
619 | 640 |
620 // Tear down the worker. | 641 // Tear down the worker. |
621 worker->Stop(); | 642 worker->Stop(); |
622 } | 643 } |
623 | 644 |
624 TEST_P(EmbeddedWorkerInstanceTestP, Detach) { | 645 TEST_P(EmbeddedWorkerInstanceTestP, Detach) { |
625 const int64_t version_id = 55L; | 646 const int64_t version_id = 55L; |
626 const GURL pattern("http://example.com/"); | 647 const GURL pattern("http://example.com/"); |
627 const GURL url("http://example.com/worker.js"); | 648 const GURL url("http://example.com/worker.js"); |
628 std::unique_ptr<EmbeddedWorkerInstance> worker = | 649 std::unique_ptr<EmbeddedWorkerInstance> worker = |
629 embedded_worker_registry()->CreateWorker(); | 650 embedded_worker_registry()->CreateWorker(); |
630 helper_->SimulateAddProcessToPattern(pattern, | 651 helper_->SimulateAddProcessToPattern(pattern, |
631 helper_->mock_render_process_id()); | 652 helper_->mock_render_process_id()); |
632 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 653 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
633 worker->AddListener(this); | 654 worker->AddListener(this); |
634 | 655 |
635 // Start the worker. | 656 // Start the worker. |
636 base::RunLoop run_loop; | 657 base::RunLoop run_loop; |
637 std::unique_ptr<EmbeddedWorkerStartParams> params( | 658 std::unique_ptr<EmbeddedWorkerStartParams> params = |
638 CreateStartParams(version_id, pattern, url)); | 659 CreateStartParams(version_id, pattern, url); |
639 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 660 worker->Start( |
640 run_loop.QuitClosure())); | 661 std::move(params), CreateEventDispatcher(), |
| 662 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
641 run_loop.Run(); | 663 run_loop.Run(); |
642 | 664 |
643 // Detach. | 665 // Detach. |
644 int process_id = worker->process_id(); | 666 int process_id = worker->process_id(); |
645 worker->Detach(); | 667 worker->Detach(); |
646 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); | 668 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); |
647 | 669 |
648 // Send the registry a message from the detached worker. Nothing should | 670 // Send the registry a message from the detached worker. Nothing should |
649 // happen. | 671 // happen. |
650 embedded_worker_registry()->OnWorkerStarted(process_id, | 672 embedded_worker_registry()->OnWorkerStarted(process_id, |
(...skipping 15 matching lines...) Expand all Loading... |
666 } | 688 } |
667 | 689 |
668 std::unique_ptr<EmbeddedWorkerInstance> worker = | 690 std::unique_ptr<EmbeddedWorkerInstance> worker = |
669 embedded_worker_registry()->CreateWorker(); | 691 embedded_worker_registry()->CreateWorker(); |
670 helper_->SimulateAddProcessToPattern(pattern, | 692 helper_->SimulateAddProcessToPattern(pattern, |
671 helper_->mock_render_process_id()); | 693 helper_->mock_render_process_id()); |
672 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 694 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
673 worker->AddListener(this); | 695 worker->AddListener(this); |
674 | 696 |
675 // Attempt to start the worker. | 697 // Attempt to start the worker. |
676 std::unique_ptr<EmbeddedWorkerStartParams> params( | 698 std::unique_ptr<EmbeddedWorkerStartParams> params = |
677 CreateStartParams(version_id, pattern, url)); | 699 CreateStartParams(version_id, pattern, url); |
678 if (is_mojo_enabled()) { | 700 if (is_mojo_enabled()) { |
679 worker->Start(std::move(params), | 701 worker->Start(std::move(params), CreateEventDispatcher(), |
680 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 702 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
681 base::RunLoop().RunUntilIdle(); | 703 base::RunLoop().RunUntilIdle(); |
682 } else { | 704 } else { |
683 base::RunLoop run_loop; | 705 base::RunLoop run_loop; |
684 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status, | 706 worker->Start( |
685 run_loop.QuitClosure())); | 707 std::move(params), CreateEventDispatcher(), |
| 708 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
686 run_loop.Run(); | 709 run_loop.Run(); |
687 } | 710 } |
688 | 711 |
689 if (is_mojo_enabled()) { | 712 if (is_mojo_enabled()) { |
690 // Worker should handle the failure of binding as detach. | 713 // Worker should handle the failure of binding as detach. |
691 ASSERT_EQ(3u, events_.size()); | 714 ASSERT_EQ(3u, events_.size()); |
692 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 715 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
693 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 716 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
694 EXPECT_EQ(DETACHED, events_[2].type); | 717 EXPECT_EQ(DETACHED, events_[2].type); |
695 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[2].status); | 718 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[2].status); |
(...skipping 11 matching lines...) Expand all Loading... |
707 class FailEmbeddedWorkerInstanceClientImpl | 730 class FailEmbeddedWorkerInstanceClientImpl |
708 : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient { | 731 : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient { |
709 public: | 732 public: |
710 explicit FailEmbeddedWorkerInstanceClientImpl( | 733 explicit FailEmbeddedWorkerInstanceClientImpl( |
711 base::WeakPtr<EmbeddedWorkerTestHelper> helper) | 734 base::WeakPtr<EmbeddedWorkerTestHelper> helper) |
712 : EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient(helper) {} | 735 : EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient(helper) {} |
713 | 736 |
714 private: | 737 private: |
715 void StartWorker( | 738 void StartWorker( |
716 const EmbeddedWorkerStartParams& /* unused */, | 739 const EmbeddedWorkerStartParams& /* unused */, |
717 service_manager::mojom::InterfaceProviderPtr /* unused */, | 740 mojom::ServiceWorkerEventDispatcherRequest /* unused */) override { |
718 service_manager::mojom::InterfaceProviderRequest /* unused */) override { | |
719 helper_->mock_instance_clients()->clear(); | 741 helper_->mock_instance_clients()->clear(); |
720 } | 742 } |
721 }; | 743 }; |
722 | 744 |
723 TEST_P(EmbeddedWorkerInstanceTestP, RemoveRemoteInterface) { | 745 TEST_P(EmbeddedWorkerInstanceTestP, RemoveRemoteInterface) { |
724 if (!is_mojo_enabled()) | 746 if (!is_mojo_enabled()) |
725 return; | 747 return; |
726 | 748 |
727 const int64_t version_id = 55L; | 749 const int64_t version_id = 55L; |
728 const GURL pattern("http://example.com/"); | 750 const GURL pattern("http://example.com/"); |
729 const GURL url("http://example.com/worker.js"); | 751 const GURL url("http://example.com/worker.js"); |
730 | 752 |
731 // Let StartWorker fail; binding is discarded in the middle of IPC | 753 // Let StartWorker fail; binding is discarded in the middle of IPC |
732 helper_->RegisterMockInstanceClient( | 754 helper_->RegisterMockInstanceClient( |
733 base::MakeUnique<FailEmbeddedWorkerInstanceClientImpl>( | 755 base::MakeUnique<FailEmbeddedWorkerInstanceClientImpl>( |
734 helper_->AsWeakPtr())); | 756 helper_->AsWeakPtr())); |
735 ASSERT_EQ(mock_instance_clients()->size(), 1UL); | 757 ASSERT_EQ(mock_instance_clients()->size(), 1UL); |
736 | 758 |
737 std::unique_ptr<EmbeddedWorkerInstance> worker = | 759 std::unique_ptr<EmbeddedWorkerInstance> worker = |
738 embedded_worker_registry()->CreateWorker(); | 760 embedded_worker_registry()->CreateWorker(); |
739 helper_->SimulateAddProcessToPattern(pattern, | 761 helper_->SimulateAddProcessToPattern(pattern, |
740 helper_->mock_render_process_id()); | 762 helper_->mock_render_process_id()); |
741 worker->AddListener(this); | 763 worker->AddListener(this); |
742 | 764 |
743 // Attempt to start the worker. | 765 // Attempt to start the worker. |
744 std::unique_ptr<EmbeddedWorkerStartParams> params( | 766 std::unique_ptr<EmbeddedWorkerStartParams> params = |
745 CreateStartParams(version_id, pattern, url)); | 767 CreateStartParams(version_id, pattern, url); |
746 worker->Start(std::move(params), | 768 worker->Start(std::move(params), CreateEventDispatcher(), |
747 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 769 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
748 base::RunLoop().RunUntilIdle(); | 770 base::RunLoop().RunUntilIdle(); |
749 | 771 |
750 // Worker should handle the sudden shutdown as detach. | 772 // Worker should handle the sudden shutdown as detach. |
751 ASSERT_EQ(3u, events_.size()); | 773 ASSERT_EQ(3u, events_.size()); |
752 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 774 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
753 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 775 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
754 EXPECT_EQ(DETACHED, events_[2].type); | 776 EXPECT_EQ(DETACHED, events_[2].type); |
755 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[2].status); | 777 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[2].status); |
756 } | 778 } |
757 | 779 |
758 INSTANTIATE_TEST_CASE_P(EmbeddedWorkerInstanceTest, | 780 INSTANTIATE_TEST_CASE_P(EmbeddedWorkerInstanceTest, |
759 EmbeddedWorkerInstanceTestP, | 781 EmbeddedWorkerInstanceTestP, |
760 ::testing::Values(false, true)); | 782 ::testing::Values(false, true)); |
761 | 783 |
762 } // namespace content | 784 } // namespace content |
OLD | NEW |