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" |
(...skipping 164 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
175 : binding_(this, std::move(request)) {} | 175 : binding_(this, std::move(request)) {} |
176 | 176 |
177 mojo::StrongBinding<mojom::TestMojoService> binding_; | 177 mojo::StrongBinding<mojom::TestMojoService> binding_; |
178 }; | 178 }; |
179 | 179 |
180 } // namespace | 180 } // namespace |
181 | 181 |
182 class ServiceWorkerVersionTest : public testing::Test { | 182 class ServiceWorkerVersionTest : public testing::Test { |
183 protected: | 183 protected: |
184 struct RunningStateListener : public ServiceWorkerVersion::Listener { | 184 struct RunningStateListener : public ServiceWorkerVersion::Listener { |
185 RunningStateListener() : last_status(ServiceWorkerVersion::STOPPED) {} | 185 RunningStateListener() |
| 186 : last_status(ServiceWorkerVersion::RunningStatus::STOPPED) {} |
186 ~RunningStateListener() override {} | 187 ~RunningStateListener() override {} |
187 void OnRunningStateChanged(ServiceWorkerVersion* version) override { | 188 void OnRunningStateChanged(ServiceWorkerVersion* version) override { |
188 last_status = version->running_status(); | 189 last_status = version->running_status(); |
189 } | 190 } |
190 ServiceWorkerVersion::RunningStatus last_status; | 191 ServiceWorkerVersion::RunningStatus last_status; |
191 }; | 192 }; |
192 | 193 |
193 ServiceWorkerVersionTest() | 194 ServiceWorkerVersionTest() |
194 : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} | 195 : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} |
195 | 196 |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
243 void SimulateDispatchEvent(ServiceWorkerMetrics::EventType event_type) { | 244 void SimulateDispatchEvent(ServiceWorkerMetrics::EventType event_type) { |
244 ServiceWorkerStatusCode status = | 245 ServiceWorkerStatusCode status = |
245 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 246 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
246 | 247 |
247 // Make sure worker is running. | 248 // Make sure worker is running. |
248 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 249 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
249 version_->RunAfterStartWorker(event_type, runner->QuitClosure(), | 250 version_->RunAfterStartWorker(event_type, runner->QuitClosure(), |
250 CreateReceiverOnCurrentThread(&status)); | 251 CreateReceiverOnCurrentThread(&status)); |
251 runner->Run(); | 252 runner->Run(); |
252 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); | 253 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); |
253 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 254 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 255 version_->running_status()); |
254 | 256 |
255 // Start request, as if an event is being dispatched. | 257 // Start request, as if an event is being dispatched. |
256 int request_id = version_->StartRequest( | 258 int request_id = version_->StartRequest( |
257 event_type, CreateReceiverOnCurrentThread(&status)); | 259 event_type, CreateReceiverOnCurrentThread(&status)); |
258 base::RunLoop().RunUntilIdle(); | 260 base::RunLoop().RunUntilIdle(); |
259 | 261 |
260 // And finish request, as if a response to the event was received. | 262 // And finish request, as if a response to the event was received. |
261 EXPECT_TRUE(version_->FinishRequest(request_id, true)); | 263 EXPECT_TRUE(version_->FinishRequest(request_id, true)); |
262 base::RunLoop().RunUntilIdle(); | 264 base::RunLoop().RunUntilIdle(); |
263 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); | 265 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) { | 381 TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) { |
380 // Call StartWorker() multiple times. | 382 // Call StartWorker() multiple times. |
381 ServiceWorkerStatusCode status1 = SERVICE_WORKER_ERROR_FAILED; | 383 ServiceWorkerStatusCode status1 = SERVICE_WORKER_ERROR_FAILED; |
382 ServiceWorkerStatusCode status2 = SERVICE_WORKER_ERROR_FAILED; | 384 ServiceWorkerStatusCode status2 = SERVICE_WORKER_ERROR_FAILED; |
383 ServiceWorkerStatusCode status3 = SERVICE_WORKER_ERROR_FAILED; | 385 ServiceWorkerStatusCode status3 = SERVICE_WORKER_ERROR_FAILED; |
384 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 386 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
385 CreateReceiverOnCurrentThread(&status1)); | 387 CreateReceiverOnCurrentThread(&status1)); |
386 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 388 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
387 CreateReceiverOnCurrentThread(&status2)); | 389 CreateReceiverOnCurrentThread(&status2)); |
388 | 390 |
389 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 391 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STARTING, |
| 392 version_->running_status()); |
390 base::RunLoop().RunUntilIdle(); | 393 base::RunLoop().RunUntilIdle(); |
391 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 394 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 395 version_->running_status()); |
392 | 396 |
393 // Call StartWorker() after it's started. | 397 // Call StartWorker() after it's started. |
394 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 398 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
395 CreateReceiverOnCurrentThread(&status3)); | 399 CreateReceiverOnCurrentThread(&status3)); |
396 base::RunLoop().RunUntilIdle(); | 400 base::RunLoop().RunUntilIdle(); |
397 | 401 |
398 // All should just succeed. | 402 // All should just succeed. |
399 EXPECT_EQ(SERVICE_WORKER_OK, status1); | 403 EXPECT_EQ(SERVICE_WORKER_OK, status1); |
400 EXPECT_EQ(SERVICE_WORKER_OK, status2); | 404 EXPECT_EQ(SERVICE_WORKER_OK, status2); |
401 EXPECT_EQ(SERVICE_WORKER_OK, status3); | 405 EXPECT_EQ(SERVICE_WORKER_OK, status3); |
402 | 406 |
403 // Call StopWorker() multiple times. | 407 // Call StopWorker() multiple times. |
404 status1 = SERVICE_WORKER_ERROR_FAILED; | 408 status1 = SERVICE_WORKER_ERROR_FAILED; |
405 status2 = SERVICE_WORKER_ERROR_FAILED; | 409 status2 = SERVICE_WORKER_ERROR_FAILED; |
406 version_->StopWorker(CreateReceiverOnCurrentThread(&status1)); | 410 version_->StopWorker(CreateReceiverOnCurrentThread(&status1)); |
407 version_->StopWorker(CreateReceiverOnCurrentThread(&status2)); | 411 version_->StopWorker(CreateReceiverOnCurrentThread(&status2)); |
408 | 412 |
409 EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status()); | 413 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPING, |
| 414 version_->running_status()); |
410 base::RunLoop().RunUntilIdle(); | 415 base::RunLoop().RunUntilIdle(); |
411 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 416 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPED, |
| 417 version_->running_status()); |
412 | 418 |
413 // All StopWorker should just succeed. | 419 // All StopWorker should just succeed. |
414 EXPECT_EQ(SERVICE_WORKER_OK, status1); | 420 EXPECT_EQ(SERVICE_WORKER_OK, status1); |
415 EXPECT_EQ(SERVICE_WORKER_OK, status2); | 421 EXPECT_EQ(SERVICE_WORKER_OK, status2); |
416 | 422 |
417 // Start worker again. | 423 // Start worker again. |
418 status1 = SERVICE_WORKER_ERROR_FAILED; | 424 status1 = SERVICE_WORKER_ERROR_FAILED; |
419 status2 = SERVICE_WORKER_ERROR_FAILED; | 425 status2 = SERVICE_WORKER_ERROR_FAILED; |
420 status3 = SERVICE_WORKER_ERROR_FAILED; | 426 status3 = SERVICE_WORKER_ERROR_FAILED; |
421 | 427 |
422 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 428 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
423 CreateReceiverOnCurrentThread(&status1)); | 429 CreateReceiverOnCurrentThread(&status1)); |
424 | 430 |
425 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 431 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STARTING, |
| 432 version_->running_status()); |
426 base::RunLoop().RunUntilIdle(); | 433 base::RunLoop().RunUntilIdle(); |
427 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 434 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 435 version_->running_status()); |
428 | 436 |
429 // Call StopWorker() | 437 // Call StopWorker() |
430 status2 = SERVICE_WORKER_ERROR_FAILED; | 438 status2 = SERVICE_WORKER_ERROR_FAILED; |
431 version_->StopWorker(CreateReceiverOnCurrentThread(&status2)); | 439 version_->StopWorker(CreateReceiverOnCurrentThread(&status2)); |
432 | 440 |
433 // And try calling StartWorker while StopWorker is in queue. | 441 // And try calling StartWorker while StopWorker is in queue. |
434 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 442 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
435 CreateReceiverOnCurrentThread(&status3)); | 443 CreateReceiverOnCurrentThread(&status3)); |
436 | 444 |
437 EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status()); | 445 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPING, |
| 446 version_->running_status()); |
438 base::RunLoop().RunUntilIdle(); | 447 base::RunLoop().RunUntilIdle(); |
439 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 448 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 449 version_->running_status()); |
440 | 450 |
441 // All should just succeed. | 451 // All should just succeed. |
442 EXPECT_EQ(SERVICE_WORKER_OK, status1); | 452 EXPECT_EQ(SERVICE_WORKER_OK, status1); |
443 EXPECT_EQ(SERVICE_WORKER_OK, status2); | 453 EXPECT_EQ(SERVICE_WORKER_OK, status2); |
444 EXPECT_EQ(SERVICE_WORKER_OK, status3); | 454 EXPECT_EQ(SERVICE_WORKER_OK, status3); |
445 } | 455 } |
446 | 456 |
447 TEST_F(ServiceWorkerVersionTest, DispatchEventToStoppedWorker) { | 457 TEST_F(ServiceWorkerVersionTest, DispatchEventToStoppedWorker) { |
448 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 458 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPED, |
| 459 version_->running_status()); |
449 | 460 |
450 // Dispatch an event without starting the worker. | 461 // Dispatch an event without starting the worker. |
451 version_->SetStatus(ServiceWorkerVersion::INSTALLING); | 462 version_->SetStatus(ServiceWorkerVersion::INSTALLING); |
452 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::INSTALL); | 463 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::INSTALL); |
453 | 464 |
454 // The worker should be now started. | 465 // The worker should be now started. |
455 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 466 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 467 version_->running_status()); |
456 | 468 |
457 // Stop the worker, and then dispatch an event immediately after that. | 469 // Stop the worker, and then dispatch an event immediately after that. |
458 ServiceWorkerStatusCode stop_status = SERVICE_WORKER_ERROR_FAILED; | 470 ServiceWorkerStatusCode stop_status = SERVICE_WORKER_ERROR_FAILED; |
459 version_->StopWorker(CreateReceiverOnCurrentThread(&stop_status)); | 471 version_->StopWorker(CreateReceiverOnCurrentThread(&stop_status)); |
460 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::INSTALL); | 472 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::INSTALL); |
461 EXPECT_EQ(SERVICE_WORKER_OK, stop_status); | 473 EXPECT_EQ(SERVICE_WORKER_OK, stop_status); |
462 | 474 |
463 // The worker should be now started again. | 475 // The worker should be now started again. |
464 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 476 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 477 version_->running_status()); |
465 } | 478 } |
466 | 479 |
467 TEST_F(ServiceWorkerVersionTest, StartUnregisteredButStillLiveWorker) { | 480 TEST_F(ServiceWorkerVersionTest, StartUnregisteredButStillLiveWorker) { |
468 // Start the worker. | 481 // Start the worker. |
469 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 482 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
470 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 483 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
471 CreateReceiverOnCurrentThread(&status)); | 484 CreateReceiverOnCurrentThread(&status)); |
472 base::RunLoop().RunUntilIdle(); | 485 base::RunLoop().RunUntilIdle(); |
473 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 486 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 487 version_->running_status()); |
474 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 488 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
475 | 489 |
476 // Delete the registration. | 490 // Delete the registration. |
477 status = SERVICE_WORKER_ERROR_FAILED; | 491 status = SERVICE_WORKER_ERROR_FAILED; |
478 helper_->context()->storage()->DeleteRegistration( | 492 helper_->context()->storage()->DeleteRegistration( |
479 registration_->id(), registration_->pattern().GetOrigin(), | 493 registration_->id(), registration_->pattern().GetOrigin(), |
480 CreateReceiverOnCurrentThread(&status)); | 494 CreateReceiverOnCurrentThread(&status)); |
481 base::RunLoop().RunUntilIdle(); | 495 base::RunLoop().RunUntilIdle(); |
482 ASSERT_EQ(SERVICE_WORKER_OK, status); | 496 ASSERT_EQ(SERVICE_WORKER_OK, status); |
483 | 497 |
484 // The live registration is marked as deleted, but still exists. | 498 // The live registration is marked as deleted, but still exists. |
485 ASSERT_TRUE(registration_->is_deleted()); | 499 ASSERT_TRUE(registration_->is_deleted()); |
486 | 500 |
487 // Stop the worker. | 501 // Stop the worker. |
488 ServiceWorkerStatusCode stop_status = SERVICE_WORKER_ERROR_FAILED; | 502 ServiceWorkerStatusCode stop_status = SERVICE_WORKER_ERROR_FAILED; |
489 version_->StopWorker(CreateReceiverOnCurrentThread(&stop_status)); | 503 version_->StopWorker(CreateReceiverOnCurrentThread(&stop_status)); |
490 base::RunLoop().RunUntilIdle(); | 504 base::RunLoop().RunUntilIdle(); |
491 EXPECT_EQ(SERVICE_WORKER_OK, stop_status); | 505 EXPECT_EQ(SERVICE_WORKER_OK, stop_status); |
492 | 506 |
493 // Dispatch an event on the unregistered and stopped but still live worker. | 507 // Dispatch an event on the unregistered and stopped but still live worker. |
494 status = SERVICE_WORKER_ERROR_FAILED; | 508 status = SERVICE_WORKER_ERROR_FAILED; |
495 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME); | 509 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME); |
496 | 510 |
497 // The worker should be now started again. | 511 // The worker should be now started again. |
498 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 512 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 513 version_->running_status()); |
499 } | 514 } |
500 | 515 |
501 TEST_F(ServiceWorkerVersionTest, ReceiveMessageFromWorker) { | 516 TEST_F(ServiceWorkerVersionTest, ReceiveMessageFromWorker) { |
502 // Start worker. | 517 // Start worker. |
503 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 518 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
504 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 519 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
505 CreateReceiverOnCurrentThread(&status)); | 520 CreateReceiverOnCurrentThread(&status)); |
506 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 521 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STARTING, |
| 522 version_->running_status()); |
507 base::RunLoop().RunUntilIdle(); | 523 base::RunLoop().RunUntilIdle(); |
508 EXPECT_EQ(SERVICE_WORKER_OK, status); | 524 EXPECT_EQ(SERVICE_WORKER_OK, status); |
509 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 525 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 526 version_->running_status()); |
510 | 527 |
511 MessageReceiverFromWorker receiver(version_->embedded_worker()); | 528 MessageReceiverFromWorker receiver(version_->embedded_worker()); |
512 | 529 |
513 // Simulate sending some dummy values from the worker. | 530 // Simulate sending some dummy values from the worker. |
514 helper_->SimulateSendValueToBrowser( | 531 helper_->SimulateSendValueToBrowser( |
515 version_->embedded_worker()->embedded_worker_id(), 555); | 532 version_->embedded_worker()->embedded_worker_id(), 555); |
516 helper_->SimulateSendValueToBrowser( | 533 helper_->SimulateSendValueToBrowser( |
517 version_->embedded_worker()->embedded_worker_id(), 777); | 534 version_->embedded_worker()->embedded_worker_id(), 777); |
518 | 535 |
519 // Verify the receiver received the values. | 536 // Verify the receiver received the values. |
(...skipping 123 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
643 | 660 |
644 EXPECT_EQ(SERVICE_WORKER_OK, status); | 661 EXPECT_EQ(SERVICE_WORKER_OK, status); |
645 EXPECT_LT(idle_time, version_->idle_time_); | 662 EXPECT_LT(idle_time, version_->idle_time_); |
646 } | 663 } |
647 | 664 |
648 TEST_F(ServiceWorkerVersionTest, SetDevToolsAttached) { | 665 TEST_F(ServiceWorkerVersionTest, SetDevToolsAttached) { |
649 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 666 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
650 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 667 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
651 CreateReceiverOnCurrentThread(&status)); | 668 CreateReceiverOnCurrentThread(&status)); |
652 | 669 |
653 ASSERT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 670 ASSERT_EQ(ServiceWorkerVersion::RunningStatus::STARTING, |
| 671 version_->running_status()); |
654 | 672 |
655 ASSERT_TRUE(version_->timeout_timer_.IsRunning()); | 673 ASSERT_TRUE(version_->timeout_timer_.IsRunning()); |
656 ASSERT_FALSE(version_->start_time_.is_null()); | 674 ASSERT_FALSE(version_->start_time_.is_null()); |
657 ASSERT_FALSE(version_->skip_recording_startup_time_); | 675 ASSERT_FALSE(version_->skip_recording_startup_time_); |
658 | 676 |
659 // Simulate DevTools is attached. This should deactivate the timer for start | 677 // Simulate DevTools is attached. This should deactivate the timer for start |
660 // timeout, but not stop the timer itself. | 678 // timeout, but not stop the timer itself. |
661 version_->SetDevToolsAttached(true); | 679 version_->SetDevToolsAttached(true); |
662 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 680 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
663 EXPECT_TRUE(version_->start_time_.is_null()); | 681 EXPECT_TRUE(version_->start_time_.is_null()); |
664 EXPECT_TRUE(version_->skip_recording_startup_time_); | 682 EXPECT_TRUE(version_->skip_recording_startup_time_); |
665 | 683 |
666 // Simulate DevTools is detached. This should reactivate the timer for start | 684 // Simulate DevTools is detached. This should reactivate the timer for start |
667 // timeout. | 685 // timeout. |
668 version_->SetDevToolsAttached(false); | 686 version_->SetDevToolsAttached(false); |
669 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 687 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
670 EXPECT_FALSE(version_->start_time_.is_null()); | 688 EXPECT_FALSE(version_->start_time_.is_null()); |
671 EXPECT_TRUE(version_->skip_recording_startup_time_); | 689 EXPECT_TRUE(version_->skip_recording_startup_time_); |
672 | 690 |
673 base::RunLoop().RunUntilIdle(); | 691 base::RunLoop().RunUntilIdle(); |
674 EXPECT_EQ(SERVICE_WORKER_OK, status); | 692 EXPECT_EQ(SERVICE_WORKER_OK, status); |
675 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 693 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 694 version_->running_status()); |
676 } | 695 } |
677 | 696 |
678 TEST_F(ServiceWorkerVersionTest, StoppingBeforeDestruct) { | 697 TEST_F(ServiceWorkerVersionTest, StoppingBeforeDestruct) { |
679 RunningStateListener listener; | 698 RunningStateListener listener; |
680 version_->AddListener(&listener); | 699 version_->AddListener(&listener); |
681 | 700 |
682 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 701 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
683 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 702 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
684 CreateReceiverOnCurrentThread(&status)); | 703 CreateReceiverOnCurrentThread(&status)); |
685 base::RunLoop().RunUntilIdle(); | 704 base::RunLoop().RunUntilIdle(); |
686 EXPECT_EQ(SERVICE_WORKER_OK, status); | 705 EXPECT_EQ(SERVICE_WORKER_OK, status); |
687 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 706 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
688 EXPECT_EQ(ServiceWorkerVersion::RUNNING, listener.last_status); | 707 version_->running_status()); |
| 708 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, listener.last_status); |
689 | 709 |
690 version_ = nullptr; | 710 version_ = nullptr; |
691 EXPECT_EQ(ServiceWorkerVersion::STOPPING, listener.last_status); | 711 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPING, |
| 712 listener.last_status); |
692 } | 713 } |
693 | 714 |
694 // Test that update isn't triggered for a non-stale worker. | 715 // Test that update isn't triggered for a non-stale worker. |
695 TEST_F(ServiceWorkerVersionTest, StaleUpdate_FreshWorker) { | 716 TEST_F(ServiceWorkerVersionTest, StaleUpdate_FreshWorker) { |
696 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 717 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
697 registration_->SetActiveVersion(version_); | 718 registration_->SetActiveVersion(version_); |
698 registration_->set_last_update_check(base::Time::Now()); | 719 registration_->set_last_update_check(base::Time::Now()); |
699 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::PUSH); | 720 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::PUSH); |
700 | 721 |
701 EXPECT_TRUE(version_->stale_time_.is_null()); | 722 EXPECT_TRUE(version_->stale_time_.is_null()); |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
805 base::RunLoop().RunUntilIdle(); | 826 base::RunLoop().RunUntilIdle(); |
806 | 827 |
807 // Create a request. | 828 // Create a request. |
808 int request_id = | 829 int request_id = |
809 version_->StartRequest(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, | 830 version_->StartRequest(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, |
810 CreateReceiverOnCurrentThread(&status)); | 831 CreateReceiverOnCurrentThread(&status)); |
811 base::RunLoop().RunUntilIdle(); | 832 base::RunLoop().RunUntilIdle(); |
812 | 833 |
813 // Callback has not completed yet. | 834 // Callback has not completed yet. |
814 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); | 835 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); |
815 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 836 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 837 version_->running_status()); |
816 | 838 |
817 // Simulate timeout. | 839 // Simulate timeout. |
818 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 840 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
819 version_->SetAllRequestExpirations(base::TimeTicks::Now()); | 841 version_->SetAllRequestExpirations(base::TimeTicks::Now()); |
820 version_->timeout_timer_.user_task().Run(); | 842 version_->timeout_timer_.user_task().Run(); |
821 base::RunLoop().RunUntilIdle(); | 843 base::RunLoop().RunUntilIdle(); |
822 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 844 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
823 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 845 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPED, |
| 846 version_->running_status()); |
824 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 847 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
825 } | 848 } |
826 | 849 |
827 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeout) { | 850 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeout) { |
828 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 851 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
829 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 852 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
830 | 853 |
831 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 854 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
832 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 855 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
833 base::RunLoop().RunUntilIdle(); | 856 base::RunLoop().RunUntilIdle(); |
834 | 857 |
835 // Create a request that should expire Now(). | 858 // Create a request that should expire Now(). |
836 int request_id = version_->StartRequestWithCustomTimeout( | 859 int request_id = version_->StartRequestWithCustomTimeout( |
837 ServiceWorkerMetrics::EventType::SYNC, | 860 ServiceWorkerMetrics::EventType::SYNC, |
838 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), | 861 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), |
839 ServiceWorkerVersion::CONTINUE_ON_TIMEOUT); | 862 ServiceWorkerVersion::CONTINUE_ON_TIMEOUT); |
840 | 863 |
841 base::RunLoop().RunUntilIdle(); | 864 base::RunLoop().RunUntilIdle(); |
842 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 865 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
843 version_->timeout_timer_.user_task().Run(); | 866 version_->timeout_timer_.user_task().Run(); |
844 base::RunLoop().RunUntilIdle(); | 867 base::RunLoop().RunUntilIdle(); |
845 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 868 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
846 | 869 |
847 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 870 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
848 | 871 |
849 // CONTINUE_ON_TIMEOUT timeouts don't stop the service worker. | 872 // CONTINUE_ON_TIMEOUT timeouts don't stop the service worker. |
850 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 873 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 874 version_->running_status()); |
851 } | 875 } |
852 | 876 |
853 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeoutKill) { | 877 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeoutKill) { |
854 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 878 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
855 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 879 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
856 | 880 |
857 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 881 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
858 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 882 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
859 base::RunLoop().RunUntilIdle(); | 883 base::RunLoop().RunUntilIdle(); |
860 | 884 |
861 // Create a request that should expire Now(). | 885 // Create a request that should expire Now(). |
862 int request_id = version_->StartRequestWithCustomTimeout( | 886 int request_id = version_->StartRequestWithCustomTimeout( |
863 ServiceWorkerMetrics::EventType::SYNC, | 887 ServiceWorkerMetrics::EventType::SYNC, |
864 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), | 888 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), |
865 ServiceWorkerVersion::KILL_ON_TIMEOUT); | 889 ServiceWorkerVersion::KILL_ON_TIMEOUT); |
866 | 890 |
867 base::RunLoop().RunUntilIdle(); | 891 base::RunLoop().RunUntilIdle(); |
868 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 892 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
869 version_->timeout_timer_.user_task().Run(); | 893 version_->timeout_timer_.user_task().Run(); |
870 base::RunLoop().RunUntilIdle(); | 894 base::RunLoop().RunUntilIdle(); |
871 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 895 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
872 | 896 |
873 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 897 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
874 | 898 |
875 // KILL_ON_TIMEOUT timeouts should stop the service worker. | 899 // KILL_ON_TIMEOUT timeouts should stop the service worker. |
876 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 900 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPED, |
| 901 version_->running_status()); |
877 } | 902 } |
878 | 903 |
879 TEST_F(ServiceWorkerVersionTest, MixedRequestTimeouts) { | 904 TEST_F(ServiceWorkerVersionTest, MixedRequestTimeouts) { |
880 ServiceWorkerStatusCode sync_status = | 905 ServiceWorkerStatusCode sync_status = |
881 SERVICE_WORKER_ERROR_NETWORK; // dummy value | 906 SERVICE_WORKER_ERROR_NETWORK; // dummy value |
882 ServiceWorkerStatusCode fetch_status = | 907 ServiceWorkerStatusCode fetch_status = |
883 SERVICE_WORKER_ERROR_NETWORK; // dummy value | 908 SERVICE_WORKER_ERROR_NETWORK; // dummy value |
884 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 909 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
885 | 910 |
886 version_->StartWorker(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, | 911 version_->StartWorker(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, |
(...skipping 13 matching lines...) Expand all Loading... |
900 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, sync_status); | 925 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, sync_status); |
901 | 926 |
902 // Verify the sync has timed out but not the fetch. | 927 // Verify the sync has timed out but not the fetch. |
903 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 928 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
904 version_->timeout_timer_.user_task().Run(); | 929 version_->timeout_timer_.user_task().Run(); |
905 base::RunLoop().RunUntilIdle(); | 930 base::RunLoop().RunUntilIdle(); |
906 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, sync_status); | 931 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, sync_status); |
907 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, fetch_status); | 932 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, fetch_status); |
908 | 933 |
909 // Background sync timeouts don't stop the service worker. | 934 // Background sync timeouts don't stop the service worker. |
910 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 935 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 936 version_->running_status()); |
911 | 937 |
912 // Gracefully handle the sync event finishing after the timeout. | 938 // Gracefully handle the sync event finishing after the timeout. |
913 EXPECT_FALSE(version_->FinishRequest(sync_request_id, true)); | 939 EXPECT_FALSE(version_->FinishRequest(sync_request_id, true)); |
914 | 940 |
915 // Verify that the fetch times out later. | 941 // Verify that the fetch times out later. |
916 version_->SetAllRequestExpirations(base::TimeTicks::Now()); | 942 version_->SetAllRequestExpirations(base::TimeTicks::Now()); |
917 version_->timeout_timer_.user_task().Run(); | 943 version_->timeout_timer_.user_task().Run(); |
918 base::RunLoop().RunUntilIdle(); | 944 base::RunLoop().RunUntilIdle(); |
919 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, fetch_status); | 945 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, fetch_status); |
920 | 946 |
921 // Fetch request should no longer exist. | 947 // Fetch request should no longer exist. |
922 EXPECT_FALSE(version_->FinishRequest(fetch_request_id, true)); | 948 EXPECT_FALSE(version_->FinishRequest(fetch_request_id, true)); |
923 | 949 |
924 // Other timeouts do stop the service worker. | 950 // Other timeouts do stop the service worker. |
925 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 951 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPED, |
| 952 version_->running_status()); |
926 } | 953 } |
927 | 954 |
928 TEST_F(ServiceWorkerFailToStartTest, RendererCrash) { | 955 TEST_F(ServiceWorkerFailToStartTest, RendererCrash) { |
929 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 956 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
930 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 957 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
931 CreateReceiverOnCurrentThread(&status)); | 958 CreateReceiverOnCurrentThread(&status)); |
932 base::RunLoop().RunUntilIdle(); | 959 base::RunLoop().RunUntilIdle(); |
933 | 960 |
934 // Callback has not completed yet. | 961 // Callback has not completed yet. |
935 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); | 962 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); |
936 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 963 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STARTING, |
| 964 version_->running_status()); |
937 | 965 |
938 // Simulate renderer crash: do what | 966 // Simulate renderer crash: do what |
939 // ServiceWorkerDispatcherHost::OnFilterRemoved does. | 967 // ServiceWorkerDispatcherHost::OnFilterRemoved does. |
940 int process_id = helper_->mock_render_process_id(); | 968 int process_id = helper_->mock_render_process_id(); |
941 helper_->context()->RemoveAllProviderHostsForProcess(process_id); | 969 helper_->context()->RemoveAllProviderHostsForProcess(process_id); |
942 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( | 970 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( |
943 process_id); | 971 process_id); |
944 base::RunLoop().RunUntilIdle(); | 972 base::RunLoop().RunUntilIdle(); |
945 | 973 |
946 // Callback completed. | 974 // Callback completed. |
947 EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status); | 975 EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status); |
948 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 976 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPED, |
| 977 version_->running_status()); |
949 } | 978 } |
950 | 979 |
951 TEST_F(ServiceWorkerFailToStartTest, Timeout) { | 980 TEST_F(ServiceWorkerFailToStartTest, Timeout) { |
952 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 981 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
953 | 982 |
954 // Start starting the worker. | 983 // Start starting the worker. |
955 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 984 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
956 CreateReceiverOnCurrentThread(&status)); | 985 CreateReceiverOnCurrentThread(&status)); |
957 base::RunLoop().RunUntilIdle(); | 986 base::RunLoop().RunUntilIdle(); |
958 | 987 |
959 // Callback has not completed yet. | 988 // Callback has not completed yet. |
960 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); | 989 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); |
961 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 990 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STARTING, |
| 991 version_->running_status()); |
962 | 992 |
963 // Simulate timeout. | 993 // Simulate timeout. |
964 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 994 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
965 version_->start_time_ = | 995 version_->start_time_ = |
966 base::TimeTicks::Now() - | 996 base::TimeTicks::Now() - |
967 base::TimeDelta::FromMinutes( | 997 base::TimeDelta::FromMinutes( |
968 ServiceWorkerVersion::kStartNewWorkerTimeoutMinutes + 1); | 998 ServiceWorkerVersion::kStartNewWorkerTimeoutMinutes + 1); |
969 version_->timeout_timer_.user_task().Run(); | 999 version_->timeout_timer_.user_task().Run(); |
970 base::RunLoop().RunUntilIdle(); | 1000 base::RunLoop().RunUntilIdle(); |
971 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 1001 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
972 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 1002 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPED, |
| 1003 version_->running_status()); |
973 } | 1004 } |
974 | 1005 |
975 // Test that a service worker stalled in stopping will timeout and not get in a | 1006 // Test that a service worker stalled in stopping will timeout and not get in a |
976 // sticky error state. | 1007 // sticky error state. |
977 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenStart) { | 1008 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenStart) { |
978 // Start a worker. | 1009 // Start a worker. |
979 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 1010 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
980 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1011 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
981 CreateReceiverOnCurrentThread(&status)); | 1012 CreateReceiverOnCurrentThread(&status)); |
982 base::RunLoop().RunUntilIdle(); | 1013 base::RunLoop().RunUntilIdle(); |
983 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1014 EXPECT_EQ(SERVICE_WORKER_OK, status); |
984 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1015 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1016 version_->running_status()); |
985 | 1017 |
986 // Try to stop the worker. | 1018 // Try to stop the worker. |
987 status = SERVICE_WORKER_ERROR_FAILED; | 1019 status = SERVICE_WORKER_ERROR_FAILED; |
988 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); | 1020 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); |
989 EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status()); | 1021 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPING, |
| 1022 version_->running_status()); |
990 base::RunLoop().RunUntilIdle(); | 1023 base::RunLoop().RunUntilIdle(); |
991 | 1024 |
992 // Worker is now stalled in stopping. Verify a fast timeout is in place. | 1025 // Worker is now stalled in stopping. Verify a fast timeout is in place. |
993 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 1026 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
994 EXPECT_EQ(base::TimeDelta::FromSeconds( | 1027 EXPECT_EQ(base::TimeDelta::FromSeconds( |
995 ServiceWorkerVersion::kStopWorkerTimeoutSeconds), | 1028 ServiceWorkerVersion::kStopWorkerTimeoutSeconds), |
996 version_->timeout_timer_.GetCurrentDelay()); | 1029 version_->timeout_timer_.GetCurrentDelay()); |
997 | 1030 |
998 // Simulate timeout. | 1031 // Simulate timeout. |
999 version_->stop_time_ = | 1032 version_->stop_time_ = |
1000 base::TimeTicks::Now() - | 1033 base::TimeTicks::Now() - |
1001 base::TimeDelta::FromSeconds( | 1034 base::TimeDelta::FromSeconds( |
1002 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); | 1035 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); |
1003 version_->timeout_timer_.user_task().Run(); | 1036 version_->timeout_timer_.user_task().Run(); |
1004 base::RunLoop().RunUntilIdle(); | 1037 base::RunLoop().RunUntilIdle(); |
1005 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1038 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1006 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 1039 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPED, |
| 1040 version_->running_status()); |
1007 | 1041 |
1008 // Try to start the worker again. It should work. | 1042 // Try to start the worker again. It should work. |
1009 status = SERVICE_WORKER_ERROR_FAILED; | 1043 status = SERVICE_WORKER_ERROR_FAILED; |
1010 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1044 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1011 CreateReceiverOnCurrentThread(&status)); | 1045 CreateReceiverOnCurrentThread(&status)); |
1012 base::RunLoop().RunUntilIdle(); | 1046 base::RunLoop().RunUntilIdle(); |
1013 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1047 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1014 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1048 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1049 version_->running_status()); |
1015 | 1050 |
1016 // The timeout interval should be reset to normal. | 1051 // The timeout interval should be reset to normal. |
1017 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 1052 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
1018 EXPECT_EQ(base::TimeDelta::FromSeconds( | 1053 EXPECT_EQ(base::TimeDelta::FromSeconds( |
1019 ServiceWorkerVersion::kTimeoutTimerDelaySeconds), | 1054 ServiceWorkerVersion::kTimeoutTimerDelaySeconds), |
1020 version_->timeout_timer_.GetCurrentDelay()); | 1055 version_->timeout_timer_.GetCurrentDelay()); |
1021 } | 1056 } |
1022 | 1057 |
1023 // Test that a service worker stalled in stopping with a start worker | 1058 // Test that a service worker stalled in stopping with a start worker |
1024 // request queued up will timeout and restart. | 1059 // request queued up will timeout and restart. |
1025 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenRestart) { | 1060 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenRestart) { |
1026 // Start a worker. | 1061 // Start a worker. |
1027 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 1062 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
1028 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1063 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1029 CreateReceiverOnCurrentThread(&status)); | 1064 CreateReceiverOnCurrentThread(&status)); |
1030 base::RunLoop().RunUntilIdle(); | 1065 base::RunLoop().RunUntilIdle(); |
1031 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1066 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1032 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1067 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1068 version_->running_status()); |
1033 | 1069 |
1034 // Try to stop the worker. | 1070 // Try to stop the worker. |
1035 status = SERVICE_WORKER_ERROR_FAILED; | 1071 status = SERVICE_WORKER_ERROR_FAILED; |
1036 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); | 1072 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); |
1037 EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status()); | 1073 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPING, |
| 1074 version_->running_status()); |
1038 | 1075 |
1039 // Worker is now stalled in stopping. Add a start worker requset. | 1076 // Worker is now stalled in stopping. Add a start worker requset. |
1040 ServiceWorkerStatusCode start_status = SERVICE_WORKER_ERROR_FAILED; | 1077 ServiceWorkerStatusCode start_status = SERVICE_WORKER_ERROR_FAILED; |
1041 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1078 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1042 CreateReceiverOnCurrentThread(&start_status)); | 1079 CreateReceiverOnCurrentThread(&start_status)); |
1043 | 1080 |
1044 // Simulate timeout. The worker should stop and get restarted. | 1081 // Simulate timeout. The worker should stop and get restarted. |
1045 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 1082 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
1046 version_->stop_time_ = | 1083 version_->stop_time_ = |
1047 base::TimeTicks::Now() - | 1084 base::TimeTicks::Now() - |
1048 base::TimeDelta::FromSeconds( | 1085 base::TimeDelta::FromSeconds( |
1049 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); | 1086 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); |
1050 version_->timeout_timer_.user_task().Run(); | 1087 version_->timeout_timer_.user_task().Run(); |
1051 base::RunLoop().RunUntilIdle(); | 1088 base::RunLoop().RunUntilIdle(); |
1052 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1089 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1053 EXPECT_EQ(SERVICE_WORKER_OK, start_status); | 1090 EXPECT_EQ(SERVICE_WORKER_OK, start_status); |
1054 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1091 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1092 version_->running_status()); |
1055 } | 1093 } |
1056 | 1094 |
1057 TEST_F(ServiceWorkerVersionTest, RegisterForeignFetchScopes) { | 1095 TEST_F(ServiceWorkerVersionTest, RegisterForeignFetchScopes) { |
1058 version_->SetStatus(ServiceWorkerVersion::INSTALLING); | 1096 version_->SetStatus(ServiceWorkerVersion::INSTALLING); |
1059 // Start a worker. | 1097 // Start a worker. |
1060 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 1098 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
1061 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1099 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1062 CreateReceiverOnCurrentThread(&status)); | 1100 CreateReceiverOnCurrentThread(&status)); |
1063 base::RunLoop().RunUntilIdle(); | 1101 base::RunLoop().RunUntilIdle(); |
1064 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1102 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1065 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1103 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1104 version_->running_status()); |
1066 EXPECT_EQ(0, helper_->mock_render_process_host()->bad_msg_count()); | 1105 EXPECT_EQ(0, helper_->mock_render_process_host()->bad_msg_count()); |
1067 | 1106 |
1068 GURL valid_scope_1("http://www.example.com/test/subscope"); | 1107 GURL valid_scope_1("http://www.example.com/test/subscope"); |
1069 GURL valid_scope_2("http://www.example.com/test/othersubscope"); | 1108 GURL valid_scope_2("http://www.example.com/test/othersubscope"); |
1070 std::vector<GURL> valid_scopes; | 1109 std::vector<GURL> valid_scopes; |
1071 valid_scopes.push_back(valid_scope_1); | 1110 valid_scopes.push_back(valid_scope_1); |
1072 valid_scopes.push_back(valid_scope_2); | 1111 valid_scopes.push_back(valid_scope_2); |
1073 | 1112 |
1074 std::vector<url::Origin> all_origins; | 1113 std::vector<url::Origin> all_origins; |
1075 url::Origin valid_origin(GURL("https://chromium.org/")); | 1114 url::Origin valid_origin(GURL("https://chromium.org/")); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1131 } | 1170 } |
1132 | 1171 |
1133 TEST_F(ServiceWorkerVersionTest, RendererCrashDuringEvent) { | 1172 TEST_F(ServiceWorkerVersionTest, RendererCrashDuringEvent) { |
1134 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1173 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1135 | 1174 |
1136 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1175 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1137 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1176 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1138 CreateReceiverOnCurrentThread(&status)); | 1177 CreateReceiverOnCurrentThread(&status)); |
1139 base::RunLoop().RunUntilIdle(); | 1178 base::RunLoop().RunUntilIdle(); |
1140 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1179 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1141 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1180 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1181 version_->running_status()); |
1142 | 1182 |
1143 int request_id = | 1183 int request_id = |
1144 version_->StartRequest(ServiceWorkerMetrics::EventType::SYNC, | 1184 version_->StartRequest(ServiceWorkerMetrics::EventType::SYNC, |
1145 CreateReceiverOnCurrentThread(&status)); | 1185 CreateReceiverOnCurrentThread(&status)); |
1146 base::RunLoop().RunUntilIdle(); | 1186 base::RunLoop().RunUntilIdle(); |
1147 | 1187 |
1148 // Callback has not completed yet. | 1188 // Callback has not completed yet. |
1149 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1189 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1150 | 1190 |
1151 // Simulate renderer crash: do what | 1191 // Simulate renderer crash: do what |
1152 // ServiceWorkerDispatcherHost::OnFilterRemoved does. | 1192 // ServiceWorkerDispatcherHost::OnFilterRemoved does. |
1153 int process_id = helper_->mock_render_process_id(); | 1193 int process_id = helper_->mock_render_process_id(); |
1154 helper_->context()->RemoveAllProviderHostsForProcess(process_id); | 1194 helper_->context()->RemoveAllProviderHostsForProcess(process_id); |
1155 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( | 1195 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( |
1156 process_id); | 1196 process_id); |
1157 base::RunLoop().RunUntilIdle(); | 1197 base::RunLoop().RunUntilIdle(); |
1158 | 1198 |
1159 // Callback completed. | 1199 // Callback completed. |
1160 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); | 1200 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); |
1161 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 1201 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::STOPPED, |
| 1202 version_->running_status()); |
1162 | 1203 |
1163 // Request already failed, calling finsh should return false. | 1204 // Request already failed, calling finsh should return false. |
1164 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 1205 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
1165 } | 1206 } |
1166 | 1207 |
1167 TEST_F(ServiceWorkerVersionWithMojoTest, MojoService) { | 1208 TEST_F(ServiceWorkerVersionWithMojoTest, MojoService) { |
1168 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1209 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1169 | 1210 |
1170 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1211 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1171 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1212 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1172 CreateReceiverOnCurrentThread(&status)); | 1213 CreateReceiverOnCurrentThread(&status)); |
1173 base::RunLoop().RunUntilIdle(); | 1214 base::RunLoop().RunUntilIdle(); |
1174 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1215 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1175 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1216 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1217 version_->running_status()); |
1176 | 1218 |
1177 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1219 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1178 int request_id = version_->StartRequest( | 1220 int request_id = version_->StartRequest( |
1179 ServiceWorkerMetrics::EventType::SYNC, | 1221 ServiceWorkerMetrics::EventType::SYNC, |
1180 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1222 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1181 base::WeakPtr<mojom::TestMojoService> service = | 1223 base::WeakPtr<mojom::TestMojoService> service = |
1182 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); | 1224 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); |
1183 service->DoSomething(runner->QuitClosure()); | 1225 service->DoSomething(runner->QuitClosure()); |
1184 runner->Run(); | 1226 runner->Run(); |
1185 | 1227 |
1186 // Mojo service does exist in worker, so error callback should not have been | 1228 // Mojo service does exist in worker, so error callback should not have been |
1187 // called and FinishRequest should return true. | 1229 // called and FinishRequest should return true. |
1188 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1230 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1189 EXPECT_TRUE(version_->FinishRequest(request_id, true)); | 1231 EXPECT_TRUE(version_->FinishRequest(request_id, true)); |
1190 } | 1232 } |
1191 | 1233 |
1192 TEST_F(ServiceWorkerVersionTest, NonExistentMojoService) { | 1234 TEST_F(ServiceWorkerVersionTest, NonExistentMojoService) { |
1193 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1235 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1194 | 1236 |
1195 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1237 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1196 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1238 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1197 CreateReceiverOnCurrentThread(&status)); | 1239 CreateReceiverOnCurrentThread(&status)); |
1198 base::RunLoop().RunUntilIdle(); | 1240 base::RunLoop().RunUntilIdle(); |
1199 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1241 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1200 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1242 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1243 version_->running_status()); |
1201 | 1244 |
1202 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1245 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1203 int request_id = version_->StartRequest( | 1246 int request_id = version_->StartRequest( |
1204 ServiceWorkerMetrics::EventType::SYNC, | 1247 ServiceWorkerMetrics::EventType::SYNC, |
1205 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1248 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1206 base::WeakPtr<mojom::TestMojoService> service = | 1249 base::WeakPtr<mojom::TestMojoService> service = |
1207 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); | 1250 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); |
1208 service->DoSomething(runner->QuitClosure()); | 1251 service->DoSomething(runner->QuitClosure()); |
1209 runner->Run(); | 1252 runner->Run(); |
1210 | 1253 |
1211 // Mojo service doesn't exist in worker, so error callback should have been | 1254 // Mojo service doesn't exist in worker, so error callback should have been |
1212 // called and FinishRequest should return false. | 1255 // called and FinishRequest should return false. |
1213 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); | 1256 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); |
1214 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 1257 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
1215 } | 1258 } |
1216 | 1259 |
1217 TEST_F(ServiceWorkerVersionTest, DispatchEvent) { | 1260 TEST_F(ServiceWorkerVersionTest, DispatchEvent) { |
1218 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1261 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1219 | 1262 |
1220 // Activate and start worker. | 1263 // Activate and start worker. |
1221 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1264 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1222 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1265 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1223 CreateReceiverOnCurrentThread(&status)); | 1266 CreateReceiverOnCurrentThread(&status)); |
1224 base::RunLoop().RunUntilIdle(); | 1267 base::RunLoop().RunUntilIdle(); |
1225 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1268 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1226 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1269 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1270 version_->running_status()); |
1227 | 1271 |
1228 // Start request and dispatch test event. | 1272 // Start request and dispatch test event. |
1229 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1273 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1230 int request_id = version_->StartRequest( | 1274 int request_id = version_->StartRequest( |
1231 ServiceWorkerMetrics::EventType::SYNC, | 1275 ServiceWorkerMetrics::EventType::SYNC, |
1232 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1276 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1233 int received_request_id = 0; | 1277 int received_request_id = 0; |
1234 std::string received_data; | 1278 std::string received_data; |
1235 version_->DispatchEvent<TestMsg_TestEventResult>( | 1279 version_->DispatchEvent<TestMsg_TestEventResult>( |
1236 request_id, TestMsg_TestEvent(request_id), | 1280 request_id, TestMsg_TestEvent(request_id), |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1320 | 1364 |
1321 TEST_F(ServiceWorkerVersionTest, DispatchConcurrentEvent) { | 1365 TEST_F(ServiceWorkerVersionTest, DispatchConcurrentEvent) { |
1322 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1366 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1323 | 1367 |
1324 // Activate and start worker. | 1368 // Activate and start worker. |
1325 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1369 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1326 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1370 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1327 CreateReceiverOnCurrentThread(&status)); | 1371 CreateReceiverOnCurrentThread(&status)); |
1328 base::RunLoop().RunUntilIdle(); | 1372 base::RunLoop().RunUntilIdle(); |
1329 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1373 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1330 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1374 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1375 version_->running_status()); |
1331 | 1376 |
1332 // Start first request and dispatch test event. | 1377 // Start first request and dispatch test event. |
1333 scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner); | 1378 scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner); |
1334 ServiceWorkerStatusCode status1 = SERVICE_WORKER_OK; // dummy value | 1379 ServiceWorkerStatusCode status1 = SERVICE_WORKER_OK; // dummy value |
1335 int request_id1 = version_->StartRequest( | 1380 int request_id1 = version_->StartRequest( |
1336 ServiceWorkerMetrics::EventType::SYNC, | 1381 ServiceWorkerMetrics::EventType::SYNC, |
1337 CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure())); | 1382 CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure())); |
1338 int received_request_id1 = 0; | 1383 int received_request_id1 = 0; |
1339 std::string received_data1; | 1384 std::string received_data1; |
1340 version_->DispatchEvent<TestMsg_TestEventResult>( | 1385 version_->DispatchEvent<TestMsg_TestEventResult>( |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1398 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Completed) { | 1443 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Completed) { |
1399 ServiceWorkerStatusCode status = | 1444 ServiceWorkerStatusCode status = |
1400 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1445 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1401 | 1446 |
1402 // Activate and start worker. | 1447 // Activate and start worker. |
1403 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1448 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1404 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1449 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1405 CreateReceiverOnCurrentThread(&status)); | 1450 CreateReceiverOnCurrentThread(&status)); |
1406 base::RunLoop().RunUntilIdle(); | 1451 base::RunLoop().RunUntilIdle(); |
1407 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1452 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1408 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1453 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1454 version_->running_status()); |
1409 | 1455 |
1410 // Start request and dispatch test event. | 1456 // Start request and dispatch test event. |
1411 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1457 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1412 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1458 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1413 int request_id = version_->StartRequest( | 1459 int request_id = version_->StartRequest( |
1414 ServiceWorkerMetrics::EventType::SYNC, | 1460 ServiceWorkerMetrics::EventType::SYNC, |
1415 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1461 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1416 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( | 1462 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( |
1417 request_id, TestMsg_TestEvent(request_id)); | 1463 request_id, TestMsg_TestEvent(request_id)); |
1418 | 1464 |
(...skipping 16 matching lines...) Expand all Loading... |
1435 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Rejected) { | 1481 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Rejected) { |
1436 ServiceWorkerStatusCode status = | 1482 ServiceWorkerStatusCode status = |
1437 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1483 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1438 | 1484 |
1439 // Activate and start worker. | 1485 // Activate and start worker. |
1440 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1486 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1441 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1487 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1442 CreateReceiverOnCurrentThread(&status)); | 1488 CreateReceiverOnCurrentThread(&status)); |
1443 base::RunLoop().RunUntilIdle(); | 1489 base::RunLoop().RunUntilIdle(); |
1444 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1490 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1445 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1491 EXPECT_EQ(ServiceWorkerVersion::RunningStatus::RUNNING, |
| 1492 version_->running_status()); |
1446 | 1493 |
1447 // Start request and dispatch test event. | 1494 // Start request and dispatch test event. |
1448 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1495 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1449 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1496 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1450 int request_id = version_->StartRequest( | 1497 int request_id = version_->StartRequest( |
1451 ServiceWorkerMetrics::EventType::SYNC, | 1498 ServiceWorkerMetrics::EventType::SYNC, |
1452 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1499 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1453 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( | 1500 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( |
1454 request_id, TestMsg_TestEvent(request_id)); | 1501 request_id, TestMsg_TestEvent(request_id)); |
1455 | 1502 |
1456 // Verify event got dispatched to worker. | 1503 // Verify event got dispatched to worker. |
1457 base::RunLoop().RunUntilIdle(); | 1504 base::RunLoop().RunUntilIdle(); |
1458 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); | 1505 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); |
1459 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); | 1506 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); |
1460 EXPECT_EQ(TestMsg_TestEvent::ID, msg->type()); | 1507 EXPECT_EQ(TestMsg_TestEvent::ID, msg->type()); |
1461 | 1508 |
1462 // Simulate sending reply to event. | 1509 // Simulate sending reply to event. |
1463 helper_->SimulateSendSimpleEventResult( | 1510 helper_->SimulateSendSimpleEventResult( |
1464 version_->embedded_worker()->embedded_worker_id(), request_id, | 1511 version_->embedded_worker()->embedded_worker_id(), request_id, |
1465 blink::WebServiceWorkerEventResultRejected); | 1512 blink::WebServiceWorkerEventResultRejected); |
1466 runner->Run(); | 1513 runner->Run(); |
1467 | 1514 |
1468 // Verify callback was called with correct status. | 1515 // Verify callback was called with correct status. |
1469 EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status); | 1516 EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status); |
1470 } | 1517 } |
1471 | 1518 |
1472 } // namespace content | 1519 } // namespace content |
OLD | NEW |