OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 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/service_worker_version.h" | 5 #include "content/browser/service_worker/service_worker_version.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 #include <tuple> | 8 #include <tuple> |
9 | 9 |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
11 #include "base/memory/ptr_util.h" | 11 #include "base/memory/ptr_util.h" |
12 #include "base/run_loop.h" | 12 #include "base/run_loop.h" |
13 #include "content/browser/service_worker/embedded_worker_registry.h" | 13 #include "content/browser/service_worker/embedded_worker_registry.h" |
| 14 #include "content/browser/service_worker/embedded_worker_status.h" |
14 #include "content/browser/service_worker/embedded_worker_test_helper.h" | 15 #include "content/browser/service_worker/embedded_worker_test_helper.h" |
15 #include "content/browser/service_worker/service_worker_context_core.h" | 16 #include "content/browser/service_worker/service_worker_context_core.h" |
16 #include "content/browser/service_worker/service_worker_registration.h" | 17 #include "content/browser/service_worker/service_worker_registration.h" |
17 #include "content/browser/service_worker/service_worker_test_utils.h" | 18 #include "content/browser/service_worker/service_worker_test_utils.h" |
18 #include "content/common/service_worker/service_worker_utils.h" | 19 #include "content/common/service_worker/service_worker_utils.h" |
19 #include "content/public/test/mock_render_process_host.h" | 20 #include "content/public/test/mock_render_process_host.h" |
20 #include "content/public/test/test_browser_thread_bundle.h" | 21 #include "content/public/test/test_browser_thread_bundle.h" |
21 #include "content/public/test/test_mojo_service.mojom.h" | 22 #include "content/public/test/test_mojo_service.mojom.h" |
22 #include "content/public/test/test_utils.h" | 23 #include "content/public/test/test_utils.h" |
23 #include "mojo/public/cpp/bindings/strong_binding.h" | 24 #include "mojo/public/cpp/bindings/strong_binding.h" |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
122 // A specialized listener class to receive test messages from a worker. | 123 // A specialized listener class to receive test messages from a worker. |
123 class MessageReceiverFromWorker : public EmbeddedWorkerInstance::Listener { | 124 class MessageReceiverFromWorker : public EmbeddedWorkerInstance::Listener { |
124 public: | 125 public: |
125 explicit MessageReceiverFromWorker(EmbeddedWorkerInstance* instance) | 126 explicit MessageReceiverFromWorker(EmbeddedWorkerInstance* instance) |
126 : instance_(instance) { | 127 : instance_(instance) { |
127 instance_->AddListener(this); | 128 instance_->AddListener(this); |
128 } | 129 } |
129 ~MessageReceiverFromWorker() override { instance_->RemoveListener(this); } | 130 ~MessageReceiverFromWorker() override { instance_->RemoveListener(this); } |
130 | 131 |
131 void OnStarted() override { NOTREACHED(); } | 132 void OnStarted() override { NOTREACHED(); } |
132 void OnStopped(EmbeddedWorkerInstance::Status old_status) override { | 133 void OnStopped(EmbeddedWorkerStatus old_status) override { NOTREACHED(); } |
133 NOTREACHED(); | |
134 } | |
135 bool OnMessageReceived(const IPC::Message& message) override { | 134 bool OnMessageReceived(const IPC::Message& message) override { |
136 bool handled = true; | 135 bool handled = true; |
137 IPC_BEGIN_MESSAGE_MAP(MessageReceiverFromWorker, message) | 136 IPC_BEGIN_MESSAGE_MAP(MessageReceiverFromWorker, message) |
138 IPC_MESSAGE_HANDLER(TestMsg_MessageFromWorker, OnMessageFromWorker) | 137 IPC_MESSAGE_HANDLER(TestMsg_MessageFromWorker, OnMessageFromWorker) |
139 IPC_MESSAGE_UNHANDLED(handled = false) | 138 IPC_MESSAGE_UNHANDLED(handled = false) |
140 IPC_END_MESSAGE_MAP() | 139 IPC_END_MESSAGE_MAP() |
141 return handled; | 140 return handled; |
142 } | 141 } |
143 | 142 |
144 void OnMessageFromWorker(int value) { received_values_.push_back(value); } | 143 void OnMessageFromWorker(int value) { received_values_.push_back(value); } |
(...skipping 30 matching lines...) Expand all Loading... |
175 : binding_(this, std::move(request)) {} | 174 : binding_(this, std::move(request)) {} |
176 | 175 |
177 mojo::StrongBinding<mojom::TestMojoService> binding_; | 176 mojo::StrongBinding<mojom::TestMojoService> binding_; |
178 }; | 177 }; |
179 | 178 |
180 } // namespace | 179 } // namespace |
181 | 180 |
182 class ServiceWorkerVersionTest : public testing::Test { | 181 class ServiceWorkerVersionTest : public testing::Test { |
183 protected: | 182 protected: |
184 struct RunningStateListener : public ServiceWorkerVersion::Listener { | 183 struct RunningStateListener : public ServiceWorkerVersion::Listener { |
185 RunningStateListener() : last_status(ServiceWorkerVersion::STOPPED) {} | 184 RunningStateListener() : last_status(EmbeddedWorkerStatus::STOPPED) {} |
186 ~RunningStateListener() override {} | 185 ~RunningStateListener() override {} |
187 void OnRunningStateChanged(ServiceWorkerVersion* version) override { | 186 void OnRunningStateChanged(ServiceWorkerVersion* version) override { |
188 last_status = version->running_status(); | 187 last_status = version->running_status(); |
189 } | 188 } |
190 ServiceWorkerVersion::RunningStatus last_status; | 189 EmbeddedWorkerStatus last_status; |
191 }; | 190 }; |
192 | 191 |
193 ServiceWorkerVersionTest() | 192 ServiceWorkerVersionTest() |
194 : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} | 193 : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} |
195 | 194 |
196 void SetUp() override { | 195 void SetUp() override { |
197 helper_ = GetMessageReceiver(); | 196 helper_ = GetMessageReceiver(); |
198 | 197 |
199 helper_->context()->storage()->LazyInitialize(base::Bind(&base::DoNothing)); | 198 helper_->context()->storage()->LazyInitialize(base::Bind(&base::DoNothing)); |
200 base::RunLoop().RunUntilIdle(); | 199 base::RunLoop().RunUntilIdle(); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
243 void SimulateDispatchEvent(ServiceWorkerMetrics::EventType event_type) { | 242 void SimulateDispatchEvent(ServiceWorkerMetrics::EventType event_type) { |
244 ServiceWorkerStatusCode status = | 243 ServiceWorkerStatusCode status = |
245 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 244 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
246 | 245 |
247 // Make sure worker is running. | 246 // Make sure worker is running. |
248 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 247 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
249 version_->RunAfterStartWorker(event_type, runner->QuitClosure(), | 248 version_->RunAfterStartWorker(event_type, runner->QuitClosure(), |
250 CreateReceiverOnCurrentThread(&status)); | 249 CreateReceiverOnCurrentThread(&status)); |
251 runner->Run(); | 250 runner->Run(); |
252 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); | 251 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); |
253 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 252 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
254 | 253 |
255 // Start request, as if an event is being dispatched. | 254 // Start request, as if an event is being dispatched. |
256 int request_id = version_->StartRequest( | 255 int request_id = version_->StartRequest( |
257 event_type, CreateReceiverOnCurrentThread(&status)); | 256 event_type, CreateReceiverOnCurrentThread(&status)); |
258 base::RunLoop().RunUntilIdle(); | 257 base::RunLoop().RunUntilIdle(); |
259 | 258 |
260 // And finish request, as if a response to the event was received. | 259 // And finish request, as if a response to the event was received. |
261 EXPECT_TRUE(version_->FinishRequest(request_id, true)); | 260 EXPECT_TRUE(version_->FinishRequest(request_id, true)); |
262 base::RunLoop().RunUntilIdle(); | 261 base::RunLoop().RunUntilIdle(); |
263 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); | 262 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
379 TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) { | 378 TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) { |
380 // Call StartWorker() multiple times. | 379 // Call StartWorker() multiple times. |
381 ServiceWorkerStatusCode status1 = SERVICE_WORKER_ERROR_FAILED; | 380 ServiceWorkerStatusCode status1 = SERVICE_WORKER_ERROR_FAILED; |
382 ServiceWorkerStatusCode status2 = SERVICE_WORKER_ERROR_FAILED; | 381 ServiceWorkerStatusCode status2 = SERVICE_WORKER_ERROR_FAILED; |
383 ServiceWorkerStatusCode status3 = SERVICE_WORKER_ERROR_FAILED; | 382 ServiceWorkerStatusCode status3 = SERVICE_WORKER_ERROR_FAILED; |
384 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 383 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
385 CreateReceiverOnCurrentThread(&status1)); | 384 CreateReceiverOnCurrentThread(&status1)); |
386 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 385 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
387 CreateReceiverOnCurrentThread(&status2)); | 386 CreateReceiverOnCurrentThread(&status2)); |
388 | 387 |
389 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 388 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, version_->running_status()); |
390 base::RunLoop().RunUntilIdle(); | 389 base::RunLoop().RunUntilIdle(); |
391 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 390 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
392 | 391 |
393 // Call StartWorker() after it's started. | 392 // Call StartWorker() after it's started. |
394 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 393 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
395 CreateReceiverOnCurrentThread(&status3)); | 394 CreateReceiverOnCurrentThread(&status3)); |
396 base::RunLoop().RunUntilIdle(); | 395 base::RunLoop().RunUntilIdle(); |
397 | 396 |
398 // All should just succeed. | 397 // All should just succeed. |
399 EXPECT_EQ(SERVICE_WORKER_OK, status1); | 398 EXPECT_EQ(SERVICE_WORKER_OK, status1); |
400 EXPECT_EQ(SERVICE_WORKER_OK, status2); | 399 EXPECT_EQ(SERVICE_WORKER_OK, status2); |
401 EXPECT_EQ(SERVICE_WORKER_OK, status3); | 400 EXPECT_EQ(SERVICE_WORKER_OK, status3); |
402 | 401 |
403 // Call StopWorker() multiple times. | 402 // Call StopWorker() multiple times. |
404 status1 = SERVICE_WORKER_ERROR_FAILED; | 403 status1 = SERVICE_WORKER_ERROR_FAILED; |
405 status2 = SERVICE_WORKER_ERROR_FAILED; | 404 status2 = SERVICE_WORKER_ERROR_FAILED; |
406 version_->StopWorker(CreateReceiverOnCurrentThread(&status1)); | 405 version_->StopWorker(CreateReceiverOnCurrentThread(&status1)); |
407 version_->StopWorker(CreateReceiverOnCurrentThread(&status2)); | 406 version_->StopWorker(CreateReceiverOnCurrentThread(&status2)); |
408 | 407 |
409 EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status()); | 408 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, version_->running_status()); |
410 base::RunLoop().RunUntilIdle(); | 409 base::RunLoop().RunUntilIdle(); |
411 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 410 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
412 | 411 |
413 // All StopWorker should just succeed. | 412 // All StopWorker should just succeed. |
414 EXPECT_EQ(SERVICE_WORKER_OK, status1); | 413 EXPECT_EQ(SERVICE_WORKER_OK, status1); |
415 EXPECT_EQ(SERVICE_WORKER_OK, status2); | 414 EXPECT_EQ(SERVICE_WORKER_OK, status2); |
416 | 415 |
417 // Start worker again. | 416 // Start worker again. |
418 status1 = SERVICE_WORKER_ERROR_FAILED; | 417 status1 = SERVICE_WORKER_ERROR_FAILED; |
419 status2 = SERVICE_WORKER_ERROR_FAILED; | 418 status2 = SERVICE_WORKER_ERROR_FAILED; |
420 status3 = SERVICE_WORKER_ERROR_FAILED; | 419 status3 = SERVICE_WORKER_ERROR_FAILED; |
421 | 420 |
422 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 421 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
423 CreateReceiverOnCurrentThread(&status1)); | 422 CreateReceiverOnCurrentThread(&status1)); |
424 | 423 |
425 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 424 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, version_->running_status()); |
426 base::RunLoop().RunUntilIdle(); | 425 base::RunLoop().RunUntilIdle(); |
427 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 426 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
428 | 427 |
429 // Call StopWorker() | 428 // Call StopWorker() |
430 status2 = SERVICE_WORKER_ERROR_FAILED; | 429 status2 = SERVICE_WORKER_ERROR_FAILED; |
431 version_->StopWorker(CreateReceiverOnCurrentThread(&status2)); | 430 version_->StopWorker(CreateReceiverOnCurrentThread(&status2)); |
432 | 431 |
433 // And try calling StartWorker while StopWorker is in queue. | 432 // And try calling StartWorker while StopWorker is in queue. |
434 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 433 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
435 CreateReceiverOnCurrentThread(&status3)); | 434 CreateReceiverOnCurrentThread(&status3)); |
436 | 435 |
437 EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status()); | 436 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, version_->running_status()); |
438 base::RunLoop().RunUntilIdle(); | 437 base::RunLoop().RunUntilIdle(); |
439 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 438 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
440 | 439 |
441 // All should just succeed. | 440 // All should just succeed. |
442 EXPECT_EQ(SERVICE_WORKER_OK, status1); | 441 EXPECT_EQ(SERVICE_WORKER_OK, status1); |
443 EXPECT_EQ(SERVICE_WORKER_OK, status2); | 442 EXPECT_EQ(SERVICE_WORKER_OK, status2); |
444 EXPECT_EQ(SERVICE_WORKER_OK, status3); | 443 EXPECT_EQ(SERVICE_WORKER_OK, status3); |
445 } | 444 } |
446 | 445 |
447 TEST_F(ServiceWorkerVersionTest, DispatchEventToStoppedWorker) { | 446 TEST_F(ServiceWorkerVersionTest, DispatchEventToStoppedWorker) { |
448 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 447 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
449 | 448 |
450 // Dispatch an event without starting the worker. | 449 // Dispatch an event without starting the worker. |
451 version_->SetStatus(ServiceWorkerVersion::INSTALLING); | 450 version_->SetStatus(ServiceWorkerVersion::INSTALLING); |
452 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::INSTALL); | 451 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::INSTALL); |
453 | 452 |
454 // The worker should be now started. | 453 // The worker should be now started. |
455 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 454 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
456 | 455 |
457 // Stop the worker, and then dispatch an event immediately after that. | 456 // Stop the worker, and then dispatch an event immediately after that. |
458 ServiceWorkerStatusCode stop_status = SERVICE_WORKER_ERROR_FAILED; | 457 ServiceWorkerStatusCode stop_status = SERVICE_WORKER_ERROR_FAILED; |
459 version_->StopWorker(CreateReceiverOnCurrentThread(&stop_status)); | 458 version_->StopWorker(CreateReceiverOnCurrentThread(&stop_status)); |
460 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::INSTALL); | 459 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::INSTALL); |
461 EXPECT_EQ(SERVICE_WORKER_OK, stop_status); | 460 EXPECT_EQ(SERVICE_WORKER_OK, stop_status); |
462 | 461 |
463 // The worker should be now started again. | 462 // The worker should be now started again. |
464 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 463 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
465 } | 464 } |
466 | 465 |
467 TEST_F(ServiceWorkerVersionTest, StartUnregisteredButStillLiveWorker) { | 466 TEST_F(ServiceWorkerVersionTest, StartUnregisteredButStillLiveWorker) { |
468 // Start the worker. | 467 // Start the worker. |
469 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 468 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
470 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 469 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
471 CreateReceiverOnCurrentThread(&status)); | 470 CreateReceiverOnCurrentThread(&status)); |
472 base::RunLoop().RunUntilIdle(); | 471 base::RunLoop().RunUntilIdle(); |
473 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 472 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
474 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 473 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
475 | 474 |
476 // Delete the registration. | 475 // Delete the registration. |
477 status = SERVICE_WORKER_ERROR_FAILED; | 476 status = SERVICE_WORKER_ERROR_FAILED; |
478 helper_->context()->storage()->DeleteRegistration( | 477 helper_->context()->storage()->DeleteRegistration( |
479 registration_->id(), registration_->pattern().GetOrigin(), | 478 registration_->id(), registration_->pattern().GetOrigin(), |
480 CreateReceiverOnCurrentThread(&status)); | 479 CreateReceiverOnCurrentThread(&status)); |
481 base::RunLoop().RunUntilIdle(); | 480 base::RunLoop().RunUntilIdle(); |
482 ASSERT_EQ(SERVICE_WORKER_OK, status); | 481 ASSERT_EQ(SERVICE_WORKER_OK, status); |
483 | 482 |
484 // The live registration is marked as deleted, but still exists. | 483 // The live registration is marked as deleted, but still exists. |
485 ASSERT_TRUE(registration_->is_deleted()); | 484 ASSERT_TRUE(registration_->is_deleted()); |
486 | 485 |
487 // Stop the worker. | 486 // Stop the worker. |
488 ServiceWorkerStatusCode stop_status = SERVICE_WORKER_ERROR_FAILED; | 487 ServiceWorkerStatusCode stop_status = SERVICE_WORKER_ERROR_FAILED; |
489 version_->StopWorker(CreateReceiverOnCurrentThread(&stop_status)); | 488 version_->StopWorker(CreateReceiverOnCurrentThread(&stop_status)); |
490 base::RunLoop().RunUntilIdle(); | 489 base::RunLoop().RunUntilIdle(); |
491 EXPECT_EQ(SERVICE_WORKER_OK, stop_status); | 490 EXPECT_EQ(SERVICE_WORKER_OK, stop_status); |
492 | 491 |
493 // Dispatch an event on the unregistered and stopped but still live worker. | 492 // Dispatch an event on the unregistered and stopped but still live worker. |
494 status = SERVICE_WORKER_ERROR_FAILED; | 493 status = SERVICE_WORKER_ERROR_FAILED; |
495 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME); | 494 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME); |
496 | 495 |
497 // The worker should be now started again. | 496 // The worker should be now started again. |
498 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 497 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
499 } | 498 } |
500 | 499 |
501 TEST_F(ServiceWorkerVersionTest, ReceiveMessageFromWorker) { | 500 TEST_F(ServiceWorkerVersionTest, ReceiveMessageFromWorker) { |
502 // Start worker. | 501 // Start worker. |
503 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 502 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
504 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 503 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
505 CreateReceiverOnCurrentThread(&status)); | 504 CreateReceiverOnCurrentThread(&status)); |
506 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 505 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, version_->running_status()); |
507 base::RunLoop().RunUntilIdle(); | 506 base::RunLoop().RunUntilIdle(); |
508 EXPECT_EQ(SERVICE_WORKER_OK, status); | 507 EXPECT_EQ(SERVICE_WORKER_OK, status); |
509 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 508 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
510 | 509 |
511 MessageReceiverFromWorker receiver(version_->embedded_worker()); | 510 MessageReceiverFromWorker receiver(version_->embedded_worker()); |
512 | 511 |
513 // Simulate sending some dummy values from the worker. | 512 // Simulate sending some dummy values from the worker. |
514 helper_->SimulateSendValueToBrowser( | 513 helper_->SimulateSendValueToBrowser( |
515 version_->embedded_worker()->embedded_worker_id(), 555); | 514 version_->embedded_worker()->embedded_worker_id(), 555); |
516 helper_->SimulateSendValueToBrowser( | 515 helper_->SimulateSendValueToBrowser( |
517 version_->embedded_worker()->embedded_worker_id(), 777); | 516 version_->embedded_worker()->embedded_worker_id(), 777); |
518 | 517 |
519 // Verify the receiver received the values. | 518 // Verify the receiver received the values. |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
644 | 643 |
645 EXPECT_EQ(SERVICE_WORKER_OK, status); | 644 EXPECT_EQ(SERVICE_WORKER_OK, status); |
646 EXPECT_LT(idle_time, version_->idle_time_); | 645 EXPECT_LT(idle_time, version_->idle_time_); |
647 } | 646 } |
648 | 647 |
649 TEST_F(ServiceWorkerVersionTest, SetDevToolsAttached) { | 648 TEST_F(ServiceWorkerVersionTest, SetDevToolsAttached) { |
650 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 649 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
651 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 650 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
652 CreateReceiverOnCurrentThread(&status)); | 651 CreateReceiverOnCurrentThread(&status)); |
653 | 652 |
654 ASSERT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 653 ASSERT_EQ(EmbeddedWorkerStatus::STARTING, version_->running_status()); |
655 | 654 |
656 ASSERT_TRUE(version_->timeout_timer_.IsRunning()); | 655 ASSERT_TRUE(version_->timeout_timer_.IsRunning()); |
657 ASSERT_FALSE(version_->start_time_.is_null()); | 656 ASSERT_FALSE(version_->start_time_.is_null()); |
658 ASSERT_FALSE(version_->skip_recording_startup_time_); | 657 ASSERT_FALSE(version_->skip_recording_startup_time_); |
659 | 658 |
660 // Simulate DevTools is attached. This should deactivate the timer for start | 659 // Simulate DevTools is attached. This should deactivate the timer for start |
661 // timeout, but not stop the timer itself. | 660 // timeout, but not stop the timer itself. |
662 version_->SetDevToolsAttached(true); | 661 version_->SetDevToolsAttached(true); |
663 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 662 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
664 EXPECT_TRUE(version_->start_time_.is_null()); | 663 EXPECT_TRUE(version_->start_time_.is_null()); |
665 EXPECT_TRUE(version_->skip_recording_startup_time_); | 664 EXPECT_TRUE(version_->skip_recording_startup_time_); |
666 | 665 |
667 // Simulate DevTools is detached. This should reactivate the timer for start | 666 // Simulate DevTools is detached. This should reactivate the timer for start |
668 // timeout. | 667 // timeout. |
669 version_->SetDevToolsAttached(false); | 668 version_->SetDevToolsAttached(false); |
670 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 669 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
671 EXPECT_FALSE(version_->start_time_.is_null()); | 670 EXPECT_FALSE(version_->start_time_.is_null()); |
672 EXPECT_TRUE(version_->skip_recording_startup_time_); | 671 EXPECT_TRUE(version_->skip_recording_startup_time_); |
673 | 672 |
674 base::RunLoop().RunUntilIdle(); | 673 base::RunLoop().RunUntilIdle(); |
675 EXPECT_EQ(SERVICE_WORKER_OK, status); | 674 EXPECT_EQ(SERVICE_WORKER_OK, status); |
676 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 675 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
677 } | 676 } |
678 | 677 |
679 TEST_F(ServiceWorkerVersionTest, StoppingBeforeDestruct) { | 678 TEST_F(ServiceWorkerVersionTest, StoppingBeforeDestruct) { |
680 RunningStateListener listener; | 679 RunningStateListener listener; |
681 version_->AddListener(&listener); | 680 version_->AddListener(&listener); |
682 | 681 |
683 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 682 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
684 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 683 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
685 CreateReceiverOnCurrentThread(&status)); | 684 CreateReceiverOnCurrentThread(&status)); |
686 base::RunLoop().RunUntilIdle(); | 685 base::RunLoop().RunUntilIdle(); |
687 EXPECT_EQ(SERVICE_WORKER_OK, status); | 686 EXPECT_EQ(SERVICE_WORKER_OK, status); |
688 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 687 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
689 EXPECT_EQ(ServiceWorkerVersion::RUNNING, listener.last_status); | 688 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, listener.last_status); |
690 | 689 |
691 version_ = nullptr; | 690 version_ = nullptr; |
692 EXPECT_EQ(ServiceWorkerVersion::STOPPING, listener.last_status); | 691 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, listener.last_status); |
693 } | 692 } |
694 | 693 |
695 // Test that update isn't triggered for a non-stale worker. | 694 // Test that update isn't triggered for a non-stale worker. |
696 TEST_F(ServiceWorkerVersionTest, StaleUpdate_FreshWorker) { | 695 TEST_F(ServiceWorkerVersionTest, StaleUpdate_FreshWorker) { |
697 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 696 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
698 registration_->SetActiveVersion(version_); | 697 registration_->SetActiveVersion(version_); |
699 registration_->set_last_update_check(base::Time::Now()); | 698 registration_->set_last_update_check(base::Time::Now()); |
700 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::PUSH); | 699 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::PUSH); |
701 | 700 |
702 EXPECT_TRUE(version_->stale_time_.is_null()); | 701 EXPECT_TRUE(version_->stale_time_.is_null()); |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
806 base::RunLoop().RunUntilIdle(); | 805 base::RunLoop().RunUntilIdle(); |
807 | 806 |
808 // Create a request. | 807 // Create a request. |
809 int request_id = | 808 int request_id = |
810 version_->StartRequest(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, | 809 version_->StartRequest(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, |
811 CreateReceiverOnCurrentThread(&status)); | 810 CreateReceiverOnCurrentThread(&status)); |
812 base::RunLoop().RunUntilIdle(); | 811 base::RunLoop().RunUntilIdle(); |
813 | 812 |
814 // Callback has not completed yet. | 813 // Callback has not completed yet. |
815 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); | 814 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); |
816 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 815 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
817 | 816 |
818 // Simulate timeout. | 817 // Simulate timeout. |
819 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 818 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
820 version_->SetAllRequestExpirations(base::TimeTicks::Now()); | 819 version_->SetAllRequestExpirations(base::TimeTicks::Now()); |
821 version_->timeout_timer_.user_task().Run(); | 820 version_->timeout_timer_.user_task().Run(); |
822 base::RunLoop().RunUntilIdle(); | 821 base::RunLoop().RunUntilIdle(); |
823 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 822 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
824 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 823 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
825 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 824 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
826 } | 825 } |
827 | 826 |
828 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeout) { | 827 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeout) { |
829 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 828 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
830 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 829 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
831 | 830 |
832 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 831 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
833 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 832 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
834 base::RunLoop().RunUntilIdle(); | 833 base::RunLoop().RunUntilIdle(); |
835 | 834 |
836 // Create a request that should expire Now(). | 835 // Create a request that should expire Now(). |
837 int request_id = version_->StartRequestWithCustomTimeout( | 836 int request_id = version_->StartRequestWithCustomTimeout( |
838 ServiceWorkerMetrics::EventType::SYNC, | 837 ServiceWorkerMetrics::EventType::SYNC, |
839 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), | 838 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), |
840 ServiceWorkerVersion::CONTINUE_ON_TIMEOUT); | 839 ServiceWorkerVersion::CONTINUE_ON_TIMEOUT); |
841 | 840 |
842 base::RunLoop().RunUntilIdle(); | 841 base::RunLoop().RunUntilIdle(); |
843 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 842 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
844 version_->timeout_timer_.user_task().Run(); | 843 version_->timeout_timer_.user_task().Run(); |
845 base::RunLoop().RunUntilIdle(); | 844 base::RunLoop().RunUntilIdle(); |
846 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 845 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
847 | 846 |
848 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 847 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
849 | 848 |
850 // CONTINUE_ON_TIMEOUT timeouts don't stop the service worker. | 849 // CONTINUE_ON_TIMEOUT timeouts don't stop the service worker. |
851 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 850 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
852 } | 851 } |
853 | 852 |
854 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeoutKill) { | 853 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeoutKill) { |
855 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 854 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
856 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 855 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
857 | 856 |
858 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 857 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
859 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 858 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
860 base::RunLoop().RunUntilIdle(); | 859 base::RunLoop().RunUntilIdle(); |
861 | 860 |
862 // Create a request that should expire Now(). | 861 // Create a request that should expire Now(). |
863 int request_id = version_->StartRequestWithCustomTimeout( | 862 int request_id = version_->StartRequestWithCustomTimeout( |
864 ServiceWorkerMetrics::EventType::SYNC, | 863 ServiceWorkerMetrics::EventType::SYNC, |
865 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), | 864 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), |
866 ServiceWorkerVersion::KILL_ON_TIMEOUT); | 865 ServiceWorkerVersion::KILL_ON_TIMEOUT); |
867 | 866 |
868 base::RunLoop().RunUntilIdle(); | 867 base::RunLoop().RunUntilIdle(); |
869 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 868 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
870 version_->timeout_timer_.user_task().Run(); | 869 version_->timeout_timer_.user_task().Run(); |
871 base::RunLoop().RunUntilIdle(); | 870 base::RunLoop().RunUntilIdle(); |
872 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 871 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
873 | 872 |
874 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 873 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
875 | 874 |
876 // KILL_ON_TIMEOUT timeouts should stop the service worker. | 875 // KILL_ON_TIMEOUT timeouts should stop the service worker. |
877 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 876 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
878 } | 877 } |
879 | 878 |
880 TEST_F(ServiceWorkerVersionTest, MixedRequestTimeouts) { | 879 TEST_F(ServiceWorkerVersionTest, MixedRequestTimeouts) { |
881 ServiceWorkerStatusCode sync_status = | 880 ServiceWorkerStatusCode sync_status = |
882 SERVICE_WORKER_ERROR_NETWORK; // dummy value | 881 SERVICE_WORKER_ERROR_NETWORK; // dummy value |
883 ServiceWorkerStatusCode fetch_status = | 882 ServiceWorkerStatusCode fetch_status = |
884 SERVICE_WORKER_ERROR_NETWORK; // dummy value | 883 SERVICE_WORKER_ERROR_NETWORK; // dummy value |
885 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 884 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
886 | 885 |
887 version_->StartWorker(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, | 886 version_->StartWorker(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, |
(...skipping 13 matching lines...) Expand all Loading... |
901 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, sync_status); | 900 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, sync_status); |
902 | 901 |
903 // Verify the sync has timed out but not the fetch. | 902 // Verify the sync has timed out but not the fetch. |
904 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 903 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
905 version_->timeout_timer_.user_task().Run(); | 904 version_->timeout_timer_.user_task().Run(); |
906 base::RunLoop().RunUntilIdle(); | 905 base::RunLoop().RunUntilIdle(); |
907 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, sync_status); | 906 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, sync_status); |
908 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, fetch_status); | 907 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, fetch_status); |
909 | 908 |
910 // Background sync timeouts don't stop the service worker. | 909 // Background sync timeouts don't stop the service worker. |
911 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 910 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
912 | 911 |
913 // Gracefully handle the sync event finishing after the timeout. | 912 // Gracefully handle the sync event finishing after the timeout. |
914 EXPECT_FALSE(version_->FinishRequest(sync_request_id, true)); | 913 EXPECT_FALSE(version_->FinishRequest(sync_request_id, true)); |
915 | 914 |
916 // Verify that the fetch times out later. | 915 // Verify that the fetch times out later. |
917 version_->SetAllRequestExpirations(base::TimeTicks::Now()); | 916 version_->SetAllRequestExpirations(base::TimeTicks::Now()); |
918 version_->timeout_timer_.user_task().Run(); | 917 version_->timeout_timer_.user_task().Run(); |
919 base::RunLoop().RunUntilIdle(); | 918 base::RunLoop().RunUntilIdle(); |
920 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, fetch_status); | 919 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, fetch_status); |
921 | 920 |
922 // Fetch request should no longer exist. | 921 // Fetch request should no longer exist. |
923 EXPECT_FALSE(version_->FinishRequest(fetch_request_id, true)); | 922 EXPECT_FALSE(version_->FinishRequest(fetch_request_id, true)); |
924 | 923 |
925 // Other timeouts do stop the service worker. | 924 // Other timeouts do stop the service worker. |
926 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 925 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
927 } | 926 } |
928 | 927 |
929 TEST_F(ServiceWorkerFailToStartTest, RendererCrash) { | 928 TEST_F(ServiceWorkerFailToStartTest, RendererCrash) { |
930 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 929 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
931 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 930 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
932 CreateReceiverOnCurrentThread(&status)); | 931 CreateReceiverOnCurrentThread(&status)); |
933 base::RunLoop().RunUntilIdle(); | 932 base::RunLoop().RunUntilIdle(); |
934 | 933 |
935 // Callback has not completed yet. | 934 // Callback has not completed yet. |
936 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); | 935 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); |
937 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 936 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, version_->running_status()); |
938 | 937 |
939 // Simulate renderer crash: do what | 938 // Simulate renderer crash: do what |
940 // ServiceWorkerDispatcherHost::OnFilterRemoved does. | 939 // ServiceWorkerDispatcherHost::OnFilterRemoved does. |
941 int process_id = helper_->mock_render_process_id(); | 940 int process_id = helper_->mock_render_process_id(); |
942 helper_->context()->RemoveAllProviderHostsForProcess(process_id); | 941 helper_->context()->RemoveAllProviderHostsForProcess(process_id); |
943 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( | 942 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( |
944 process_id); | 943 process_id); |
945 base::RunLoop().RunUntilIdle(); | 944 base::RunLoop().RunUntilIdle(); |
946 | 945 |
947 // Callback completed. | 946 // Callback completed. |
948 EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status); | 947 EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status); |
949 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 948 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
950 } | 949 } |
951 | 950 |
952 TEST_F(ServiceWorkerFailToStartTest, Timeout) { | 951 TEST_F(ServiceWorkerFailToStartTest, Timeout) { |
953 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 952 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
954 | 953 |
955 // Start starting the worker. | 954 // Start starting the worker. |
956 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 955 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
957 CreateReceiverOnCurrentThread(&status)); | 956 CreateReceiverOnCurrentThread(&status)); |
958 base::RunLoop().RunUntilIdle(); | 957 base::RunLoop().RunUntilIdle(); |
959 | 958 |
960 // Callback has not completed yet. | 959 // Callback has not completed yet. |
961 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); | 960 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); |
962 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 961 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, version_->running_status()); |
963 | 962 |
964 // Simulate timeout. | 963 // Simulate timeout. |
965 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 964 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
966 version_->start_time_ = | 965 version_->start_time_ = |
967 base::TimeTicks::Now() - | 966 base::TimeTicks::Now() - |
968 base::TimeDelta::FromMinutes( | 967 base::TimeDelta::FromMinutes( |
969 ServiceWorkerVersion::kStartNewWorkerTimeoutMinutes + 1); | 968 ServiceWorkerVersion::kStartNewWorkerTimeoutMinutes + 1); |
970 version_->timeout_timer_.user_task().Run(); | 969 version_->timeout_timer_.user_task().Run(); |
971 base::RunLoop().RunUntilIdle(); | 970 base::RunLoop().RunUntilIdle(); |
972 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 971 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
973 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 972 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
974 } | 973 } |
975 | 974 |
976 // Test that a service worker stalled in stopping will timeout and not get in a | 975 // Test that a service worker stalled in stopping will timeout and not get in a |
977 // sticky error state. | 976 // sticky error state. |
978 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenStart) { | 977 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenStart) { |
979 // Start a worker. | 978 // Start a worker. |
980 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 979 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
981 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 980 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
982 CreateReceiverOnCurrentThread(&status)); | 981 CreateReceiverOnCurrentThread(&status)); |
983 base::RunLoop().RunUntilIdle(); | 982 base::RunLoop().RunUntilIdle(); |
984 EXPECT_EQ(SERVICE_WORKER_OK, status); | 983 EXPECT_EQ(SERVICE_WORKER_OK, status); |
985 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 984 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
986 | 985 |
987 // Try to stop the worker. | 986 // Try to stop the worker. |
988 status = SERVICE_WORKER_ERROR_FAILED; | 987 status = SERVICE_WORKER_ERROR_FAILED; |
989 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); | 988 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); |
990 EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status()); | 989 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, version_->running_status()); |
991 base::RunLoop().RunUntilIdle(); | 990 base::RunLoop().RunUntilIdle(); |
992 | 991 |
993 // Worker is now stalled in stopping. Verify a fast timeout is in place. | 992 // Worker is now stalled in stopping. Verify a fast timeout is in place. |
994 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 993 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
995 EXPECT_EQ(base::TimeDelta::FromSeconds( | 994 EXPECT_EQ(base::TimeDelta::FromSeconds( |
996 ServiceWorkerVersion::kStopWorkerTimeoutSeconds), | 995 ServiceWorkerVersion::kStopWorkerTimeoutSeconds), |
997 version_->timeout_timer_.GetCurrentDelay()); | 996 version_->timeout_timer_.GetCurrentDelay()); |
998 | 997 |
999 // Simulate timeout. | 998 // Simulate timeout. |
1000 version_->stop_time_ = | 999 version_->stop_time_ = |
1001 base::TimeTicks::Now() - | 1000 base::TimeTicks::Now() - |
1002 base::TimeDelta::FromSeconds( | 1001 base::TimeDelta::FromSeconds( |
1003 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); | 1002 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); |
1004 version_->timeout_timer_.user_task().Run(); | 1003 version_->timeout_timer_.user_task().Run(); |
1005 base::RunLoop().RunUntilIdle(); | 1004 base::RunLoop().RunUntilIdle(); |
1006 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1005 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1007 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 1006 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
1008 | 1007 |
1009 // Try to start the worker again. It should work. | 1008 // Try to start the worker again. It should work. |
1010 status = SERVICE_WORKER_ERROR_FAILED; | 1009 status = SERVICE_WORKER_ERROR_FAILED; |
1011 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1010 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1012 CreateReceiverOnCurrentThread(&status)); | 1011 CreateReceiverOnCurrentThread(&status)); |
1013 base::RunLoop().RunUntilIdle(); | 1012 base::RunLoop().RunUntilIdle(); |
1014 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1013 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1015 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1014 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1016 | 1015 |
1017 // The timeout interval should be reset to normal. | 1016 // The timeout interval should be reset to normal. |
1018 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 1017 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
1019 EXPECT_EQ(base::TimeDelta::FromSeconds( | 1018 EXPECT_EQ(base::TimeDelta::FromSeconds( |
1020 ServiceWorkerVersion::kTimeoutTimerDelaySeconds), | 1019 ServiceWorkerVersion::kTimeoutTimerDelaySeconds), |
1021 version_->timeout_timer_.GetCurrentDelay()); | 1020 version_->timeout_timer_.GetCurrentDelay()); |
1022 } | 1021 } |
1023 | 1022 |
1024 // Test that a service worker stalled in stopping with a start worker | 1023 // Test that a service worker stalled in stopping with a start worker |
1025 // request queued up will timeout and restart. | 1024 // request queued up will timeout and restart. |
1026 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenRestart) { | 1025 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenRestart) { |
1027 // Start a worker. | 1026 // Start a worker. |
1028 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 1027 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
1029 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1028 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1030 CreateReceiverOnCurrentThread(&status)); | 1029 CreateReceiverOnCurrentThread(&status)); |
1031 base::RunLoop().RunUntilIdle(); | 1030 base::RunLoop().RunUntilIdle(); |
1032 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1031 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1033 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1032 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1034 | 1033 |
1035 // Try to stop the worker. | 1034 // Try to stop the worker. |
1036 status = SERVICE_WORKER_ERROR_FAILED; | 1035 status = SERVICE_WORKER_ERROR_FAILED; |
1037 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); | 1036 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); |
1038 EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status()); | 1037 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, version_->running_status()); |
1039 | 1038 |
1040 // Worker is now stalled in stopping. Add a start worker requset. | 1039 // Worker is now stalled in stopping. Add a start worker requset. |
1041 ServiceWorkerStatusCode start_status = SERVICE_WORKER_ERROR_FAILED; | 1040 ServiceWorkerStatusCode start_status = SERVICE_WORKER_ERROR_FAILED; |
1042 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1041 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1043 CreateReceiverOnCurrentThread(&start_status)); | 1042 CreateReceiverOnCurrentThread(&start_status)); |
1044 | 1043 |
1045 // Simulate timeout. The worker should stop and get restarted. | 1044 // Simulate timeout. The worker should stop and get restarted. |
1046 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 1045 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
1047 version_->stop_time_ = | 1046 version_->stop_time_ = |
1048 base::TimeTicks::Now() - | 1047 base::TimeTicks::Now() - |
1049 base::TimeDelta::FromSeconds( | 1048 base::TimeDelta::FromSeconds( |
1050 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); | 1049 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); |
1051 version_->timeout_timer_.user_task().Run(); | 1050 version_->timeout_timer_.user_task().Run(); |
1052 base::RunLoop().RunUntilIdle(); | 1051 base::RunLoop().RunUntilIdle(); |
1053 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1052 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1054 EXPECT_EQ(SERVICE_WORKER_OK, start_status); | 1053 EXPECT_EQ(SERVICE_WORKER_OK, start_status); |
1055 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1054 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1056 } | 1055 } |
1057 | 1056 |
1058 TEST_F(ServiceWorkerVersionTest, RegisterForeignFetchScopes) { | 1057 TEST_F(ServiceWorkerVersionTest, RegisterForeignFetchScopes) { |
1059 version_->SetStatus(ServiceWorkerVersion::INSTALLING); | 1058 version_->SetStatus(ServiceWorkerVersion::INSTALLING); |
1060 // Start a worker. | 1059 // Start a worker. |
1061 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 1060 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
1062 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1061 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1063 CreateReceiverOnCurrentThread(&status)); | 1062 CreateReceiverOnCurrentThread(&status)); |
1064 base::RunLoop().RunUntilIdle(); | 1063 base::RunLoop().RunUntilIdle(); |
1065 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1064 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1066 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1065 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1067 EXPECT_EQ(0, helper_->mock_render_process_host()->bad_msg_count()); | 1066 EXPECT_EQ(0, helper_->mock_render_process_host()->bad_msg_count()); |
1068 | 1067 |
1069 GURL valid_scope_1("http://www.example.com/test/subscope"); | 1068 GURL valid_scope_1("http://www.example.com/test/subscope"); |
1070 GURL valid_scope_2("http://www.example.com/test/othersubscope"); | 1069 GURL valid_scope_2("http://www.example.com/test/othersubscope"); |
1071 std::vector<GURL> valid_scopes; | 1070 std::vector<GURL> valid_scopes; |
1072 valid_scopes.push_back(valid_scope_1); | 1071 valid_scopes.push_back(valid_scope_1); |
1073 valid_scopes.push_back(valid_scope_2); | 1072 valid_scopes.push_back(valid_scope_2); |
1074 | 1073 |
1075 std::vector<url::Origin> all_origins; | 1074 std::vector<url::Origin> all_origins; |
1076 url::Origin valid_origin(GURL("https://chromium.org/")); | 1075 url::Origin valid_origin(GURL("https://chromium.org/")); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1132 } | 1131 } |
1133 | 1132 |
1134 TEST_F(ServiceWorkerVersionTest, RendererCrashDuringEvent) { | 1133 TEST_F(ServiceWorkerVersionTest, RendererCrashDuringEvent) { |
1135 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1134 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1136 | 1135 |
1137 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1136 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1138 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1137 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1139 CreateReceiverOnCurrentThread(&status)); | 1138 CreateReceiverOnCurrentThread(&status)); |
1140 base::RunLoop().RunUntilIdle(); | 1139 base::RunLoop().RunUntilIdle(); |
1141 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1140 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1142 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1141 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1143 | 1142 |
1144 int request_id = | 1143 int request_id = |
1145 version_->StartRequest(ServiceWorkerMetrics::EventType::SYNC, | 1144 version_->StartRequest(ServiceWorkerMetrics::EventType::SYNC, |
1146 CreateReceiverOnCurrentThread(&status)); | 1145 CreateReceiverOnCurrentThread(&status)); |
1147 base::RunLoop().RunUntilIdle(); | 1146 base::RunLoop().RunUntilIdle(); |
1148 | 1147 |
1149 // Callback has not completed yet. | 1148 // Callback has not completed yet. |
1150 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1149 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1151 | 1150 |
1152 // Simulate renderer crash: do what | 1151 // Simulate renderer crash: do what |
1153 // ServiceWorkerDispatcherHost::OnFilterRemoved does. | 1152 // ServiceWorkerDispatcherHost::OnFilterRemoved does. |
1154 int process_id = helper_->mock_render_process_id(); | 1153 int process_id = helper_->mock_render_process_id(); |
1155 helper_->context()->RemoveAllProviderHostsForProcess(process_id); | 1154 helper_->context()->RemoveAllProviderHostsForProcess(process_id); |
1156 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( | 1155 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( |
1157 process_id); | 1156 process_id); |
1158 base::RunLoop().RunUntilIdle(); | 1157 base::RunLoop().RunUntilIdle(); |
1159 | 1158 |
1160 // Callback completed. | 1159 // Callback completed. |
1161 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); | 1160 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); |
1162 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 1161 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
1163 | 1162 |
1164 // Request already failed, calling finsh should return false. | 1163 // Request already failed, calling finsh should return false. |
1165 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 1164 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
1166 } | 1165 } |
1167 | 1166 |
1168 TEST_F(ServiceWorkerVersionWithMojoTest, MojoService) { | 1167 TEST_F(ServiceWorkerVersionWithMojoTest, MojoService) { |
1169 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1168 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1170 | 1169 |
1171 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1170 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1172 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1171 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1173 CreateReceiverOnCurrentThread(&status)); | 1172 CreateReceiverOnCurrentThread(&status)); |
1174 base::RunLoop().RunUntilIdle(); | 1173 base::RunLoop().RunUntilIdle(); |
1175 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1174 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1176 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1175 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1177 | 1176 |
1178 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1177 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1179 int request_id = version_->StartRequest( | 1178 int request_id = version_->StartRequest( |
1180 ServiceWorkerMetrics::EventType::SYNC, | 1179 ServiceWorkerMetrics::EventType::SYNC, |
1181 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1180 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1182 base::WeakPtr<mojom::TestMojoService> service = | 1181 base::WeakPtr<mojom::TestMojoService> service = |
1183 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); | 1182 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); |
1184 service->DoSomething(runner->QuitClosure()); | 1183 service->DoSomething(runner->QuitClosure()); |
1185 runner->Run(); | 1184 runner->Run(); |
1186 | 1185 |
1187 // Mojo service does exist in worker, so error callback should not have been | 1186 // Mojo service does exist in worker, so error callback should not have been |
1188 // called and FinishRequest should return true. | 1187 // called and FinishRequest should return true. |
1189 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1188 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1190 EXPECT_TRUE(version_->FinishRequest(request_id, true)); | 1189 EXPECT_TRUE(version_->FinishRequest(request_id, true)); |
1191 } | 1190 } |
1192 | 1191 |
1193 TEST_F(ServiceWorkerVersionTest, NonExistentMojoService) { | 1192 TEST_F(ServiceWorkerVersionTest, NonExistentMojoService) { |
1194 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1193 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1195 | 1194 |
1196 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1195 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1197 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1196 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1198 CreateReceiverOnCurrentThread(&status)); | 1197 CreateReceiverOnCurrentThread(&status)); |
1199 base::RunLoop().RunUntilIdle(); | 1198 base::RunLoop().RunUntilIdle(); |
1200 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1199 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1201 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1200 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1202 | 1201 |
1203 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1202 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1204 int request_id = version_->StartRequest( | 1203 int request_id = version_->StartRequest( |
1205 ServiceWorkerMetrics::EventType::SYNC, | 1204 ServiceWorkerMetrics::EventType::SYNC, |
1206 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1205 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1207 base::WeakPtr<mojom::TestMojoService> service = | 1206 base::WeakPtr<mojom::TestMojoService> service = |
1208 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); | 1207 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); |
1209 service->DoSomething(runner->QuitClosure()); | 1208 service->DoSomething(runner->QuitClosure()); |
1210 runner->Run(); | 1209 runner->Run(); |
1211 | 1210 |
1212 // Mojo service doesn't exist in worker, so error callback should have been | 1211 // Mojo service doesn't exist in worker, so error callback should have been |
1213 // called and FinishRequest should return false. | 1212 // called and FinishRequest should return false. |
1214 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); | 1213 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); |
1215 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 1214 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
1216 } | 1215 } |
1217 | 1216 |
1218 TEST_F(ServiceWorkerVersionTest, DispatchEvent) { | 1217 TEST_F(ServiceWorkerVersionTest, DispatchEvent) { |
1219 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1218 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1220 | 1219 |
1221 // Activate and start worker. | 1220 // Activate and start worker. |
1222 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1221 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1223 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1222 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1224 CreateReceiverOnCurrentThread(&status)); | 1223 CreateReceiverOnCurrentThread(&status)); |
1225 base::RunLoop().RunUntilIdle(); | 1224 base::RunLoop().RunUntilIdle(); |
1226 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1225 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1227 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1226 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1228 | 1227 |
1229 // Start request and dispatch test event. | 1228 // Start request and dispatch test event. |
1230 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1229 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1231 int request_id = version_->StartRequest( | 1230 int request_id = version_->StartRequest( |
1232 ServiceWorkerMetrics::EventType::SYNC, | 1231 ServiceWorkerMetrics::EventType::SYNC, |
1233 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1232 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1234 int received_request_id = 0; | 1233 int received_request_id = 0; |
1235 std::string received_data; | 1234 std::string received_data; |
1236 version_->DispatchEvent<TestMsg_TestEventResult>( | 1235 version_->DispatchEvent<TestMsg_TestEventResult>( |
1237 request_id, TestMsg_TestEvent(request_id), | 1236 request_id, TestMsg_TestEvent(request_id), |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1321 | 1320 |
1322 TEST_F(ServiceWorkerVersionTest, DispatchConcurrentEvent) { | 1321 TEST_F(ServiceWorkerVersionTest, DispatchConcurrentEvent) { |
1323 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1322 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1324 | 1323 |
1325 // Activate and start worker. | 1324 // Activate and start worker. |
1326 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1325 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1327 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1326 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1328 CreateReceiverOnCurrentThread(&status)); | 1327 CreateReceiverOnCurrentThread(&status)); |
1329 base::RunLoop().RunUntilIdle(); | 1328 base::RunLoop().RunUntilIdle(); |
1330 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1329 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1331 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1330 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1332 | 1331 |
1333 // Start first request and dispatch test event. | 1332 // Start first request and dispatch test event. |
1334 scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner); | 1333 scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner); |
1335 ServiceWorkerStatusCode status1 = SERVICE_WORKER_OK; // dummy value | 1334 ServiceWorkerStatusCode status1 = SERVICE_WORKER_OK; // dummy value |
1336 int request_id1 = version_->StartRequest( | 1335 int request_id1 = version_->StartRequest( |
1337 ServiceWorkerMetrics::EventType::SYNC, | 1336 ServiceWorkerMetrics::EventType::SYNC, |
1338 CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure())); | 1337 CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure())); |
1339 int received_request_id1 = 0; | 1338 int received_request_id1 = 0; |
1340 std::string received_data1; | 1339 std::string received_data1; |
1341 version_->DispatchEvent<TestMsg_TestEventResult>( | 1340 version_->DispatchEvent<TestMsg_TestEventResult>( |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1399 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Completed) { | 1398 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Completed) { |
1400 ServiceWorkerStatusCode status = | 1399 ServiceWorkerStatusCode status = |
1401 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1400 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1402 | 1401 |
1403 // Activate and start worker. | 1402 // Activate and start worker. |
1404 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1403 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1405 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1404 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1406 CreateReceiverOnCurrentThread(&status)); | 1405 CreateReceiverOnCurrentThread(&status)); |
1407 base::RunLoop().RunUntilIdle(); | 1406 base::RunLoop().RunUntilIdle(); |
1408 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1407 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1409 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1408 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1410 | 1409 |
1411 // Start request and dispatch test event. | 1410 // Start request and dispatch test event. |
1412 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1411 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1413 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1412 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1414 int request_id = version_->StartRequest( | 1413 int request_id = version_->StartRequest( |
1415 ServiceWorkerMetrics::EventType::SYNC, | 1414 ServiceWorkerMetrics::EventType::SYNC, |
1416 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1415 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1417 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( | 1416 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( |
1418 request_id, TestMsg_TestEvent(request_id)); | 1417 request_id, TestMsg_TestEvent(request_id)); |
1419 | 1418 |
(...skipping 16 matching lines...) Expand all Loading... |
1436 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Rejected) { | 1435 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Rejected) { |
1437 ServiceWorkerStatusCode status = | 1436 ServiceWorkerStatusCode status = |
1438 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1437 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1439 | 1438 |
1440 // Activate and start worker. | 1439 // Activate and start worker. |
1441 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1440 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1442 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1441 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1443 CreateReceiverOnCurrentThread(&status)); | 1442 CreateReceiverOnCurrentThread(&status)); |
1444 base::RunLoop().RunUntilIdle(); | 1443 base::RunLoop().RunUntilIdle(); |
1445 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1444 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1446 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1445 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1447 | 1446 |
1448 // Start request and dispatch test event. | 1447 // Start request and dispatch test event. |
1449 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1448 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1450 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1449 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1451 int request_id = version_->StartRequest( | 1450 int request_id = version_->StartRequest( |
1452 ServiceWorkerMetrics::EventType::SYNC, | 1451 ServiceWorkerMetrics::EventType::SYNC, |
1453 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1452 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1454 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( | 1453 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( |
1455 request_id, TestMsg_TestEvent(request_id)); | 1454 request_id, TestMsg_TestEvent(request_id)); |
1456 | 1455 |
1457 // Verify event got dispatched to worker. | 1456 // Verify event got dispatched to worker. |
1458 base::RunLoop().RunUntilIdle(); | 1457 base::RunLoop().RunUntilIdle(); |
1459 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); | 1458 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); |
1460 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); | 1459 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); |
1461 EXPECT_EQ(TestMsg_TestEvent::ID, msg->type()); | 1460 EXPECT_EQ(TestMsg_TestEvent::ID, msg->type()); |
1462 | 1461 |
1463 // Simulate sending reply to event. | 1462 // Simulate sending reply to event. |
1464 helper_->SimulateSendSimpleEventResult( | 1463 helper_->SimulateSendSimpleEventResult( |
1465 version_->embedded_worker()->embedded_worker_id(), request_id, | 1464 version_->embedded_worker()->embedded_worker_id(), request_id, |
1466 blink::WebServiceWorkerEventResultRejected); | 1465 blink::WebServiceWorkerEventResultRejected); |
1467 runner->Run(); | 1466 runner->Run(); |
1468 | 1467 |
1469 // Verify callback was called with correct status. | 1468 // Verify callback was called with correct status. |
1470 EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status); | 1469 EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status); |
1471 } | 1470 } |
1472 | 1471 |
1473 } // namespace content | 1472 } // namespace content |
OLD | NEW |