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 123 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
643 | 642 |
644 EXPECT_EQ(SERVICE_WORKER_OK, status); | 643 EXPECT_EQ(SERVICE_WORKER_OK, status); |
645 EXPECT_LT(idle_time, version_->idle_time_); | 644 EXPECT_LT(idle_time, version_->idle_time_); |
646 } | 645 } |
647 | 646 |
648 TEST_F(ServiceWorkerVersionTest, SetDevToolsAttached) { | 647 TEST_F(ServiceWorkerVersionTest, SetDevToolsAttached) { |
649 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 648 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
650 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 649 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
651 CreateReceiverOnCurrentThread(&status)); | 650 CreateReceiverOnCurrentThread(&status)); |
652 | 651 |
653 ASSERT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 652 ASSERT_EQ(EmbeddedWorkerStatus::STARTING, version_->running_status()); |
654 | 653 |
655 ASSERT_TRUE(version_->timeout_timer_.IsRunning()); | 654 ASSERT_TRUE(version_->timeout_timer_.IsRunning()); |
656 ASSERT_FALSE(version_->start_time_.is_null()); | 655 ASSERT_FALSE(version_->start_time_.is_null()); |
657 ASSERT_FALSE(version_->skip_recording_startup_time_); | 656 ASSERT_FALSE(version_->skip_recording_startup_time_); |
658 | 657 |
659 // Simulate DevTools is attached. This should deactivate the timer for start | 658 // Simulate DevTools is attached. This should deactivate the timer for start |
660 // timeout, but not stop the timer itself. | 659 // timeout, but not stop the timer itself. |
661 version_->SetDevToolsAttached(true); | 660 version_->SetDevToolsAttached(true); |
662 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 661 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
663 EXPECT_TRUE(version_->start_time_.is_null()); | 662 EXPECT_TRUE(version_->start_time_.is_null()); |
664 EXPECT_TRUE(version_->skip_recording_startup_time_); | 663 EXPECT_TRUE(version_->skip_recording_startup_time_); |
665 | 664 |
666 // Simulate DevTools is detached. This should reactivate the timer for start | 665 // Simulate DevTools is detached. This should reactivate the timer for start |
667 // timeout. | 666 // timeout. |
668 version_->SetDevToolsAttached(false); | 667 version_->SetDevToolsAttached(false); |
669 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 668 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
670 EXPECT_FALSE(version_->start_time_.is_null()); | 669 EXPECT_FALSE(version_->start_time_.is_null()); |
671 EXPECT_TRUE(version_->skip_recording_startup_time_); | 670 EXPECT_TRUE(version_->skip_recording_startup_time_); |
672 | 671 |
673 base::RunLoop().RunUntilIdle(); | 672 base::RunLoop().RunUntilIdle(); |
674 EXPECT_EQ(SERVICE_WORKER_OK, status); | 673 EXPECT_EQ(SERVICE_WORKER_OK, status); |
675 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 674 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
676 } | 675 } |
677 | 676 |
678 TEST_F(ServiceWorkerVersionTest, StoppingBeforeDestruct) { | 677 TEST_F(ServiceWorkerVersionTest, StoppingBeforeDestruct) { |
679 RunningStateListener listener; | 678 RunningStateListener listener; |
680 version_->AddListener(&listener); | 679 version_->AddListener(&listener); |
681 | 680 |
682 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 681 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
683 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 682 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
684 CreateReceiverOnCurrentThread(&status)); | 683 CreateReceiverOnCurrentThread(&status)); |
685 base::RunLoop().RunUntilIdle(); | 684 base::RunLoop().RunUntilIdle(); |
686 EXPECT_EQ(SERVICE_WORKER_OK, status); | 685 EXPECT_EQ(SERVICE_WORKER_OK, status); |
687 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 686 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
688 EXPECT_EQ(ServiceWorkerVersion::RUNNING, listener.last_status); | 687 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, listener.last_status); |
689 | 688 |
690 version_ = nullptr; | 689 version_ = nullptr; |
691 EXPECT_EQ(ServiceWorkerVersion::STOPPING, listener.last_status); | 690 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, listener.last_status); |
692 } | 691 } |
693 | 692 |
694 // Test that update isn't triggered for a non-stale worker. | 693 // Test that update isn't triggered for a non-stale worker. |
695 TEST_F(ServiceWorkerVersionTest, StaleUpdate_FreshWorker) { | 694 TEST_F(ServiceWorkerVersionTest, StaleUpdate_FreshWorker) { |
696 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 695 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
697 registration_->SetActiveVersion(version_); | 696 registration_->SetActiveVersion(version_); |
698 registration_->set_last_update_check(base::Time::Now()); | 697 registration_->set_last_update_check(base::Time::Now()); |
699 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::PUSH); | 698 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::PUSH); |
700 | 699 |
701 EXPECT_TRUE(version_->stale_time_.is_null()); | 700 EXPECT_TRUE(version_->stale_time_.is_null()); |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
805 base::RunLoop().RunUntilIdle(); | 804 base::RunLoop().RunUntilIdle(); |
806 | 805 |
807 // Create a request. | 806 // Create a request. |
808 int request_id = | 807 int request_id = |
809 version_->StartRequest(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, | 808 version_->StartRequest(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, |
810 CreateReceiverOnCurrentThread(&status)); | 809 CreateReceiverOnCurrentThread(&status)); |
811 base::RunLoop().RunUntilIdle(); | 810 base::RunLoop().RunUntilIdle(); |
812 | 811 |
813 // Callback has not completed yet. | 812 // Callback has not completed yet. |
814 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); | 813 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); |
815 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 814 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
816 | 815 |
817 // Simulate timeout. | 816 // Simulate timeout. |
818 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 817 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
819 version_->SetAllRequestExpirations(base::TimeTicks::Now()); | 818 version_->SetAllRequestExpirations(base::TimeTicks::Now()); |
820 version_->timeout_timer_.user_task().Run(); | 819 version_->timeout_timer_.user_task().Run(); |
821 base::RunLoop().RunUntilIdle(); | 820 base::RunLoop().RunUntilIdle(); |
822 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 821 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
823 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 822 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
824 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 823 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
825 } | 824 } |
826 | 825 |
827 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeout) { | 826 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeout) { |
828 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 827 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
829 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 828 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
830 | 829 |
831 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 830 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
832 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 831 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
833 base::RunLoop().RunUntilIdle(); | 832 base::RunLoop().RunUntilIdle(); |
834 | 833 |
835 // Create a request that should expire Now(). | 834 // Create a request that should expire Now(). |
836 int request_id = version_->StartRequestWithCustomTimeout( | 835 int request_id = version_->StartRequestWithCustomTimeout( |
837 ServiceWorkerMetrics::EventType::SYNC, | 836 ServiceWorkerMetrics::EventType::SYNC, |
838 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), | 837 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), |
839 ServiceWorkerVersion::CONTINUE_ON_TIMEOUT); | 838 ServiceWorkerVersion::CONTINUE_ON_TIMEOUT); |
840 | 839 |
841 base::RunLoop().RunUntilIdle(); | 840 base::RunLoop().RunUntilIdle(); |
842 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 841 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
843 version_->timeout_timer_.user_task().Run(); | 842 version_->timeout_timer_.user_task().Run(); |
844 base::RunLoop().RunUntilIdle(); | 843 base::RunLoop().RunUntilIdle(); |
845 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 844 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
846 | 845 |
847 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 846 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
848 | 847 |
849 // CONTINUE_ON_TIMEOUT timeouts don't stop the service worker. | 848 // CONTINUE_ON_TIMEOUT timeouts don't stop the service worker. |
850 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 849 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
851 } | 850 } |
852 | 851 |
853 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeoutKill) { | 852 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeoutKill) { |
854 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 853 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
855 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 854 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
856 | 855 |
857 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 856 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
858 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 857 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
859 base::RunLoop().RunUntilIdle(); | 858 base::RunLoop().RunUntilIdle(); |
860 | 859 |
861 // Create a request that should expire Now(). | 860 // Create a request that should expire Now(). |
862 int request_id = version_->StartRequestWithCustomTimeout( | 861 int request_id = version_->StartRequestWithCustomTimeout( |
863 ServiceWorkerMetrics::EventType::SYNC, | 862 ServiceWorkerMetrics::EventType::SYNC, |
864 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), | 863 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), |
865 ServiceWorkerVersion::KILL_ON_TIMEOUT); | 864 ServiceWorkerVersion::KILL_ON_TIMEOUT); |
866 | 865 |
867 base::RunLoop().RunUntilIdle(); | 866 base::RunLoop().RunUntilIdle(); |
868 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 867 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
869 version_->timeout_timer_.user_task().Run(); | 868 version_->timeout_timer_.user_task().Run(); |
870 base::RunLoop().RunUntilIdle(); | 869 base::RunLoop().RunUntilIdle(); |
871 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 870 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
872 | 871 |
873 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 872 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
874 | 873 |
875 // KILL_ON_TIMEOUT timeouts should stop the service worker. | 874 // KILL_ON_TIMEOUT timeouts should stop the service worker. |
876 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 875 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
877 } | 876 } |
878 | 877 |
879 TEST_F(ServiceWorkerVersionTest, MixedRequestTimeouts) { | 878 TEST_F(ServiceWorkerVersionTest, MixedRequestTimeouts) { |
880 ServiceWorkerStatusCode sync_status = | 879 ServiceWorkerStatusCode sync_status = |
881 SERVICE_WORKER_ERROR_NETWORK; // dummy value | 880 SERVICE_WORKER_ERROR_NETWORK; // dummy value |
882 ServiceWorkerStatusCode fetch_status = | 881 ServiceWorkerStatusCode fetch_status = |
883 SERVICE_WORKER_ERROR_NETWORK; // dummy value | 882 SERVICE_WORKER_ERROR_NETWORK; // dummy value |
884 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 883 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
885 | 884 |
886 version_->StartWorker(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, | 885 version_->StartWorker(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME, |
(...skipping 13 matching lines...) Expand all Loading... |
900 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, sync_status); | 899 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, sync_status); |
901 | 900 |
902 // Verify the sync has timed out but not the fetch. | 901 // Verify the sync has timed out but not the fetch. |
903 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 902 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
904 version_->timeout_timer_.user_task().Run(); | 903 version_->timeout_timer_.user_task().Run(); |
905 base::RunLoop().RunUntilIdle(); | 904 base::RunLoop().RunUntilIdle(); |
906 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, sync_status); | 905 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, sync_status); |
907 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, fetch_status); | 906 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, fetch_status); |
908 | 907 |
909 // Background sync timeouts don't stop the service worker. | 908 // Background sync timeouts don't stop the service worker. |
910 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 909 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
911 | 910 |
912 // Gracefully handle the sync event finishing after the timeout. | 911 // Gracefully handle the sync event finishing after the timeout. |
913 EXPECT_FALSE(version_->FinishRequest(sync_request_id, true)); | 912 EXPECT_FALSE(version_->FinishRequest(sync_request_id, true)); |
914 | 913 |
915 // Verify that the fetch times out later. | 914 // Verify that the fetch times out later. |
916 version_->SetAllRequestExpirations(base::TimeTicks::Now()); | 915 version_->SetAllRequestExpirations(base::TimeTicks::Now()); |
917 version_->timeout_timer_.user_task().Run(); | 916 version_->timeout_timer_.user_task().Run(); |
918 base::RunLoop().RunUntilIdle(); | 917 base::RunLoop().RunUntilIdle(); |
919 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, fetch_status); | 918 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, fetch_status); |
920 | 919 |
921 // Fetch request should no longer exist. | 920 // Fetch request should no longer exist. |
922 EXPECT_FALSE(version_->FinishRequest(fetch_request_id, true)); | 921 EXPECT_FALSE(version_->FinishRequest(fetch_request_id, true)); |
923 | 922 |
924 // Other timeouts do stop the service worker. | 923 // Other timeouts do stop the service worker. |
925 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 924 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
926 } | 925 } |
927 | 926 |
928 TEST_F(ServiceWorkerFailToStartTest, RendererCrash) { | 927 TEST_F(ServiceWorkerFailToStartTest, RendererCrash) { |
929 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 928 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
930 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 929 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
931 CreateReceiverOnCurrentThread(&status)); | 930 CreateReceiverOnCurrentThread(&status)); |
932 base::RunLoop().RunUntilIdle(); | 931 base::RunLoop().RunUntilIdle(); |
933 | 932 |
934 // Callback has not completed yet. | 933 // Callback has not completed yet. |
935 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); | 934 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); |
936 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 935 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, version_->running_status()); |
937 | 936 |
938 // Simulate renderer crash: do what | 937 // Simulate renderer crash: do what |
939 // ServiceWorkerDispatcherHost::OnFilterRemoved does. | 938 // ServiceWorkerDispatcherHost::OnFilterRemoved does. |
940 int process_id = helper_->mock_render_process_id(); | 939 int process_id = helper_->mock_render_process_id(); |
941 helper_->context()->RemoveAllProviderHostsForProcess(process_id); | 940 helper_->context()->RemoveAllProviderHostsForProcess(process_id); |
942 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( | 941 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( |
943 process_id); | 942 process_id); |
944 base::RunLoop().RunUntilIdle(); | 943 base::RunLoop().RunUntilIdle(); |
945 | 944 |
946 // Callback completed. | 945 // Callback completed. |
947 EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status); | 946 EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status); |
948 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 947 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
949 } | 948 } |
950 | 949 |
951 TEST_F(ServiceWorkerFailToStartTest, Timeout) { | 950 TEST_F(ServiceWorkerFailToStartTest, Timeout) { |
952 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 951 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
953 | 952 |
954 // Start starting the worker. | 953 // Start starting the worker. |
955 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 954 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
956 CreateReceiverOnCurrentThread(&status)); | 955 CreateReceiverOnCurrentThread(&status)); |
957 base::RunLoop().RunUntilIdle(); | 956 base::RunLoop().RunUntilIdle(); |
958 | 957 |
959 // Callback has not completed yet. | 958 // Callback has not completed yet. |
960 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); | 959 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); |
961 EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status()); | 960 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, version_->running_status()); |
962 | 961 |
963 // Simulate timeout. | 962 // Simulate timeout. |
964 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 963 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
965 version_->start_time_ = | 964 version_->start_time_ = |
966 base::TimeTicks::Now() - | 965 base::TimeTicks::Now() - |
967 base::TimeDelta::FromMinutes( | 966 base::TimeDelta::FromMinutes( |
968 ServiceWorkerVersion::kStartNewWorkerTimeoutMinutes + 1); | 967 ServiceWorkerVersion::kStartNewWorkerTimeoutMinutes + 1); |
969 version_->timeout_timer_.user_task().Run(); | 968 version_->timeout_timer_.user_task().Run(); |
970 base::RunLoop().RunUntilIdle(); | 969 base::RunLoop().RunUntilIdle(); |
971 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 970 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
972 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 971 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
973 } | 972 } |
974 | 973 |
975 // Test that a service worker stalled in stopping will timeout and not get in a | 974 // Test that a service worker stalled in stopping will timeout and not get in a |
976 // sticky error state. | 975 // sticky error state. |
977 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenStart) { | 976 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenStart) { |
978 // Start a worker. | 977 // Start a worker. |
979 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 978 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
980 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 979 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
981 CreateReceiverOnCurrentThread(&status)); | 980 CreateReceiverOnCurrentThread(&status)); |
982 base::RunLoop().RunUntilIdle(); | 981 base::RunLoop().RunUntilIdle(); |
983 EXPECT_EQ(SERVICE_WORKER_OK, status); | 982 EXPECT_EQ(SERVICE_WORKER_OK, status); |
984 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 983 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
985 | 984 |
986 // Try to stop the worker. | 985 // Try to stop the worker. |
987 status = SERVICE_WORKER_ERROR_FAILED; | 986 status = SERVICE_WORKER_ERROR_FAILED; |
988 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); | 987 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); |
989 EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status()); | 988 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, version_->running_status()); |
990 base::RunLoop().RunUntilIdle(); | 989 base::RunLoop().RunUntilIdle(); |
991 | 990 |
992 // Worker is now stalled in stopping. Verify a fast timeout is in place. | 991 // Worker is now stalled in stopping. Verify a fast timeout is in place. |
993 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 992 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
994 EXPECT_EQ(base::TimeDelta::FromSeconds( | 993 EXPECT_EQ(base::TimeDelta::FromSeconds( |
995 ServiceWorkerVersion::kStopWorkerTimeoutSeconds), | 994 ServiceWorkerVersion::kStopWorkerTimeoutSeconds), |
996 version_->timeout_timer_.GetCurrentDelay()); | 995 version_->timeout_timer_.GetCurrentDelay()); |
997 | 996 |
998 // Simulate timeout. | 997 // Simulate timeout. |
999 version_->stop_time_ = | 998 version_->stop_time_ = |
1000 base::TimeTicks::Now() - | 999 base::TimeTicks::Now() - |
1001 base::TimeDelta::FromSeconds( | 1000 base::TimeDelta::FromSeconds( |
1002 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); | 1001 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); |
1003 version_->timeout_timer_.user_task().Run(); | 1002 version_->timeout_timer_.user_task().Run(); |
1004 base::RunLoop().RunUntilIdle(); | 1003 base::RunLoop().RunUntilIdle(); |
1005 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1004 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1006 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 1005 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
1007 | 1006 |
1008 // Try to start the worker again. It should work. | 1007 // Try to start the worker again. It should work. |
1009 status = SERVICE_WORKER_ERROR_FAILED; | 1008 status = SERVICE_WORKER_ERROR_FAILED; |
1010 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1009 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1011 CreateReceiverOnCurrentThread(&status)); | 1010 CreateReceiverOnCurrentThread(&status)); |
1012 base::RunLoop().RunUntilIdle(); | 1011 base::RunLoop().RunUntilIdle(); |
1013 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1012 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1014 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1013 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1015 | 1014 |
1016 // The timeout interval should be reset to normal. | 1015 // The timeout interval should be reset to normal. |
1017 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 1016 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
1018 EXPECT_EQ(base::TimeDelta::FromSeconds( | 1017 EXPECT_EQ(base::TimeDelta::FromSeconds( |
1019 ServiceWorkerVersion::kTimeoutTimerDelaySeconds), | 1018 ServiceWorkerVersion::kTimeoutTimerDelaySeconds), |
1020 version_->timeout_timer_.GetCurrentDelay()); | 1019 version_->timeout_timer_.GetCurrentDelay()); |
1021 } | 1020 } |
1022 | 1021 |
1023 // Test that a service worker stalled in stopping with a start worker | 1022 // Test that a service worker stalled in stopping with a start worker |
1024 // request queued up will timeout and restart. | 1023 // request queued up will timeout and restart. |
1025 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenRestart) { | 1024 TEST_F(ServiceWorkerStallInStoppingTest, DetachThenRestart) { |
1026 // Start a worker. | 1025 // Start a worker. |
1027 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 1026 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
1028 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1027 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1029 CreateReceiverOnCurrentThread(&status)); | 1028 CreateReceiverOnCurrentThread(&status)); |
1030 base::RunLoop().RunUntilIdle(); | 1029 base::RunLoop().RunUntilIdle(); |
1031 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1030 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1032 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1031 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1033 | 1032 |
1034 // Try to stop the worker. | 1033 // Try to stop the worker. |
1035 status = SERVICE_WORKER_ERROR_FAILED; | 1034 status = SERVICE_WORKER_ERROR_FAILED; |
1036 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); | 1035 version_->StopWorker(CreateReceiverOnCurrentThread(&status)); |
1037 EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status()); | 1036 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, version_->running_status()); |
1038 | 1037 |
1039 // Worker is now stalled in stopping. Add a start worker requset. | 1038 // Worker is now stalled in stopping. Add a start worker requset. |
1040 ServiceWorkerStatusCode start_status = SERVICE_WORKER_ERROR_FAILED; | 1039 ServiceWorkerStatusCode start_status = SERVICE_WORKER_ERROR_FAILED; |
1041 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1040 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1042 CreateReceiverOnCurrentThread(&start_status)); | 1041 CreateReceiverOnCurrentThread(&start_status)); |
1043 | 1042 |
1044 // Simulate timeout. The worker should stop and get restarted. | 1043 // Simulate timeout. The worker should stop and get restarted. |
1045 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 1044 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
1046 version_->stop_time_ = | 1045 version_->stop_time_ = |
1047 base::TimeTicks::Now() - | 1046 base::TimeTicks::Now() - |
1048 base::TimeDelta::FromSeconds( | 1047 base::TimeDelta::FromSeconds( |
1049 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); | 1048 ServiceWorkerVersion::kStopWorkerTimeoutSeconds + 1); |
1050 version_->timeout_timer_.user_task().Run(); | 1049 version_->timeout_timer_.user_task().Run(); |
1051 base::RunLoop().RunUntilIdle(); | 1050 base::RunLoop().RunUntilIdle(); |
1052 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1051 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1053 EXPECT_EQ(SERVICE_WORKER_OK, start_status); | 1052 EXPECT_EQ(SERVICE_WORKER_OK, start_status); |
1054 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1053 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1055 } | 1054 } |
1056 | 1055 |
1057 TEST_F(ServiceWorkerVersionTest, RegisterForeignFetchScopes) { | 1056 TEST_F(ServiceWorkerVersionTest, RegisterForeignFetchScopes) { |
1058 version_->SetStatus(ServiceWorkerVersion::INSTALLING); | 1057 version_->SetStatus(ServiceWorkerVersion::INSTALLING); |
1059 // Start a worker. | 1058 // Start a worker. |
1060 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 1059 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
1061 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 1060 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
1062 CreateReceiverOnCurrentThread(&status)); | 1061 CreateReceiverOnCurrentThread(&status)); |
1063 base::RunLoop().RunUntilIdle(); | 1062 base::RunLoop().RunUntilIdle(); |
1064 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1063 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1065 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1064 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1066 EXPECT_EQ(0, helper_->mock_render_process_host()->bad_msg_count()); | 1065 EXPECT_EQ(0, helper_->mock_render_process_host()->bad_msg_count()); |
1067 | 1066 |
1068 GURL valid_scope_1("http://www.example.com/test/subscope"); | 1067 GURL valid_scope_1("http://www.example.com/test/subscope"); |
1069 GURL valid_scope_2("http://www.example.com/test/othersubscope"); | 1068 GURL valid_scope_2("http://www.example.com/test/othersubscope"); |
1070 std::vector<GURL> valid_scopes; | 1069 std::vector<GURL> valid_scopes; |
1071 valid_scopes.push_back(valid_scope_1); | 1070 valid_scopes.push_back(valid_scope_1); |
1072 valid_scopes.push_back(valid_scope_2); | 1071 valid_scopes.push_back(valid_scope_2); |
1073 | 1072 |
1074 std::vector<url::Origin> all_origins; | 1073 std::vector<url::Origin> all_origins; |
1075 url::Origin valid_origin(GURL("https://chromium.org/")); | 1074 url::Origin valid_origin(GURL("https://chromium.org/")); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1131 } | 1130 } |
1132 | 1131 |
1133 TEST_F(ServiceWorkerVersionTest, RendererCrashDuringEvent) { | 1132 TEST_F(ServiceWorkerVersionTest, RendererCrashDuringEvent) { |
1134 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1133 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1135 | 1134 |
1136 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1135 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1137 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1136 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1138 CreateReceiverOnCurrentThread(&status)); | 1137 CreateReceiverOnCurrentThread(&status)); |
1139 base::RunLoop().RunUntilIdle(); | 1138 base::RunLoop().RunUntilIdle(); |
1140 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1139 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1141 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1140 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1142 | 1141 |
1143 int request_id = | 1142 int request_id = |
1144 version_->StartRequest(ServiceWorkerMetrics::EventType::SYNC, | 1143 version_->StartRequest(ServiceWorkerMetrics::EventType::SYNC, |
1145 CreateReceiverOnCurrentThread(&status)); | 1144 CreateReceiverOnCurrentThread(&status)); |
1146 base::RunLoop().RunUntilIdle(); | 1145 base::RunLoop().RunUntilIdle(); |
1147 | 1146 |
1148 // Callback has not completed yet. | 1147 // Callback has not completed yet. |
1149 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1148 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1150 | 1149 |
1151 // Simulate renderer crash: do what | 1150 // Simulate renderer crash: do what |
1152 // ServiceWorkerDispatcherHost::OnFilterRemoved does. | 1151 // ServiceWorkerDispatcherHost::OnFilterRemoved does. |
1153 int process_id = helper_->mock_render_process_id(); | 1152 int process_id = helper_->mock_render_process_id(); |
1154 helper_->context()->RemoveAllProviderHostsForProcess(process_id); | 1153 helper_->context()->RemoveAllProviderHostsForProcess(process_id); |
1155 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( | 1154 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( |
1156 process_id); | 1155 process_id); |
1157 base::RunLoop().RunUntilIdle(); | 1156 base::RunLoop().RunUntilIdle(); |
1158 | 1157 |
1159 // Callback completed. | 1158 // Callback completed. |
1160 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); | 1159 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); |
1161 EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status()); | 1160 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
1162 | 1161 |
1163 // Request already failed, calling finsh should return false. | 1162 // Request already failed, calling finsh should return false. |
1164 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 1163 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
1165 } | 1164 } |
1166 | 1165 |
1167 TEST_F(ServiceWorkerVersionWithMojoTest, MojoService) { | 1166 TEST_F(ServiceWorkerVersionWithMojoTest, MojoService) { |
1168 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1167 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1169 | 1168 |
1170 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1169 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1171 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1170 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1172 CreateReceiverOnCurrentThread(&status)); | 1171 CreateReceiverOnCurrentThread(&status)); |
1173 base::RunLoop().RunUntilIdle(); | 1172 base::RunLoop().RunUntilIdle(); |
1174 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1173 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1175 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1174 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1176 | 1175 |
1177 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1176 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1178 int request_id = version_->StartRequest( | 1177 int request_id = version_->StartRequest( |
1179 ServiceWorkerMetrics::EventType::SYNC, | 1178 ServiceWorkerMetrics::EventType::SYNC, |
1180 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1179 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1181 base::WeakPtr<mojom::TestMojoService> service = | 1180 base::WeakPtr<mojom::TestMojoService> service = |
1182 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); | 1181 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); |
1183 service->DoSomething(runner->QuitClosure()); | 1182 service->DoSomething(runner->QuitClosure()); |
1184 runner->Run(); | 1183 runner->Run(); |
1185 | 1184 |
1186 // Mojo service does exist in worker, so error callback should not have been | 1185 // Mojo service does exist in worker, so error callback should not have been |
1187 // called and FinishRequest should return true. | 1186 // called and FinishRequest should return true. |
1188 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1187 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1189 EXPECT_TRUE(version_->FinishRequest(request_id, true)); | 1188 EXPECT_TRUE(version_->FinishRequest(request_id, true)); |
1190 } | 1189 } |
1191 | 1190 |
1192 TEST_F(ServiceWorkerVersionTest, NonExistentMojoService) { | 1191 TEST_F(ServiceWorkerVersionTest, NonExistentMojoService) { |
1193 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1192 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1194 | 1193 |
1195 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1194 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1196 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1195 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1197 CreateReceiverOnCurrentThread(&status)); | 1196 CreateReceiverOnCurrentThread(&status)); |
1198 base::RunLoop().RunUntilIdle(); | 1197 base::RunLoop().RunUntilIdle(); |
1199 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1198 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1200 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1199 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1201 | 1200 |
1202 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1201 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1203 int request_id = version_->StartRequest( | 1202 int request_id = version_->StartRequest( |
1204 ServiceWorkerMetrics::EventType::SYNC, | 1203 ServiceWorkerMetrics::EventType::SYNC, |
1205 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1204 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1206 base::WeakPtr<mojom::TestMojoService> service = | 1205 base::WeakPtr<mojom::TestMojoService> service = |
1207 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); | 1206 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); |
1208 service->DoSomething(runner->QuitClosure()); | 1207 service->DoSomething(runner->QuitClosure()); |
1209 runner->Run(); | 1208 runner->Run(); |
1210 | 1209 |
1211 // Mojo service doesn't exist in worker, so error callback should have been | 1210 // Mojo service doesn't exist in worker, so error callback should have been |
1212 // called and FinishRequest should return false. | 1211 // called and FinishRequest should return false. |
1213 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); | 1212 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); |
1214 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 1213 EXPECT_FALSE(version_->FinishRequest(request_id, true)); |
1215 } | 1214 } |
1216 | 1215 |
1217 TEST_F(ServiceWorkerVersionTest, DispatchEvent) { | 1216 TEST_F(ServiceWorkerVersionTest, DispatchEvent) { |
1218 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1217 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1219 | 1218 |
1220 // Activate and start worker. | 1219 // Activate and start worker. |
1221 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1220 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1222 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1221 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1223 CreateReceiverOnCurrentThread(&status)); | 1222 CreateReceiverOnCurrentThread(&status)); |
1224 base::RunLoop().RunUntilIdle(); | 1223 base::RunLoop().RunUntilIdle(); |
1225 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1224 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1226 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1225 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1227 | 1226 |
1228 // Start request and dispatch test event. | 1227 // Start request and dispatch test event. |
1229 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1228 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1230 int request_id = version_->StartRequest( | 1229 int request_id = version_->StartRequest( |
1231 ServiceWorkerMetrics::EventType::SYNC, | 1230 ServiceWorkerMetrics::EventType::SYNC, |
1232 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1231 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1233 int received_request_id = 0; | 1232 int received_request_id = 0; |
1234 std::string received_data; | 1233 std::string received_data; |
1235 version_->DispatchEvent<TestMsg_TestEventResult>( | 1234 version_->DispatchEvent<TestMsg_TestEventResult>( |
1236 request_id, TestMsg_TestEvent(request_id), | 1235 request_id, TestMsg_TestEvent(request_id), |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1320 | 1319 |
1321 TEST_F(ServiceWorkerVersionTest, DispatchConcurrentEvent) { | 1320 TEST_F(ServiceWorkerVersionTest, DispatchConcurrentEvent) { |
1322 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1321 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1323 | 1322 |
1324 // Activate and start worker. | 1323 // Activate and start worker. |
1325 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1324 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1326 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1325 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1327 CreateReceiverOnCurrentThread(&status)); | 1326 CreateReceiverOnCurrentThread(&status)); |
1328 base::RunLoop().RunUntilIdle(); | 1327 base::RunLoop().RunUntilIdle(); |
1329 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1328 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1330 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1329 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1331 | 1330 |
1332 // Start first request and dispatch test event. | 1331 // Start first request and dispatch test event. |
1333 scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner); | 1332 scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner); |
1334 ServiceWorkerStatusCode status1 = SERVICE_WORKER_OK; // dummy value | 1333 ServiceWorkerStatusCode status1 = SERVICE_WORKER_OK; // dummy value |
1335 int request_id1 = version_->StartRequest( | 1334 int request_id1 = version_->StartRequest( |
1336 ServiceWorkerMetrics::EventType::SYNC, | 1335 ServiceWorkerMetrics::EventType::SYNC, |
1337 CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure())); | 1336 CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure())); |
1338 int received_request_id1 = 0; | 1337 int received_request_id1 = 0; |
1339 std::string received_data1; | 1338 std::string received_data1; |
1340 version_->DispatchEvent<TestMsg_TestEventResult>( | 1339 version_->DispatchEvent<TestMsg_TestEventResult>( |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1398 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Completed) { | 1397 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Completed) { |
1399 ServiceWorkerStatusCode status = | 1398 ServiceWorkerStatusCode status = |
1400 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1399 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1401 | 1400 |
1402 // Activate and start worker. | 1401 // Activate and start worker. |
1403 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1402 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1404 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1403 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1405 CreateReceiverOnCurrentThread(&status)); | 1404 CreateReceiverOnCurrentThread(&status)); |
1406 base::RunLoop().RunUntilIdle(); | 1405 base::RunLoop().RunUntilIdle(); |
1407 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1406 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1408 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1407 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1409 | 1408 |
1410 // Start request and dispatch test event. | 1409 // Start request and dispatch test event. |
1411 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1410 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1412 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1411 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1413 int request_id = version_->StartRequest( | 1412 int request_id = version_->StartRequest( |
1414 ServiceWorkerMetrics::EventType::SYNC, | 1413 ServiceWorkerMetrics::EventType::SYNC, |
1415 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1414 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1416 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( | 1415 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( |
1417 request_id, TestMsg_TestEvent(request_id)); | 1416 request_id, TestMsg_TestEvent(request_id)); |
1418 | 1417 |
(...skipping 16 matching lines...) Expand all Loading... |
1435 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Rejected) { | 1434 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Rejected) { |
1436 ServiceWorkerStatusCode status = | 1435 ServiceWorkerStatusCode status = |
1437 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1436 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1438 | 1437 |
1439 // Activate and start worker. | 1438 // Activate and start worker. |
1440 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1439 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1441 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1440 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1442 CreateReceiverOnCurrentThread(&status)); | 1441 CreateReceiverOnCurrentThread(&status)); |
1443 base::RunLoop().RunUntilIdle(); | 1442 base::RunLoop().RunUntilIdle(); |
1444 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1443 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1445 EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status()); | 1444 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1446 | 1445 |
1447 // Start request and dispatch test event. | 1446 // Start request and dispatch test event. |
1448 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1447 status = SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1449 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1448 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1450 int request_id = version_->StartRequest( | 1449 int request_id = version_->StartRequest( |
1451 ServiceWorkerMetrics::EventType::SYNC, | 1450 ServiceWorkerMetrics::EventType::SYNC, |
1452 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1451 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1453 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( | 1452 version_->DispatchSimpleEvent<TestMsg_TestSimpleEventResult>( |
1454 request_id, TestMsg_TestEvent(request_id)); | 1453 request_id, TestMsg_TestEvent(request_id)); |
1455 | 1454 |
1456 // Verify event got dispatched to worker. | 1455 // Verify event got dispatched to worker. |
1457 base::RunLoop().RunUntilIdle(); | 1456 base::RunLoop().RunUntilIdle(); |
1458 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); | 1457 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); |
1459 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); | 1458 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); |
1460 EXPECT_EQ(TestMsg_TestEvent::ID, msg->type()); | 1459 EXPECT_EQ(TestMsg_TestEvent::ID, msg->type()); |
1461 | 1460 |
1462 // Simulate sending reply to event. | 1461 // Simulate sending reply to event. |
1463 helper_->SimulateSendSimpleEventResult( | 1462 helper_->SimulateSendSimpleEventResult( |
1464 version_->embedded_worker()->embedded_worker_id(), request_id, | 1463 version_->embedded_worker()->embedded_worker_id(), request_id, |
1465 blink::WebServiceWorkerEventResultRejected); | 1464 blink::WebServiceWorkerEventResultRejected); |
1466 runner->Run(); | 1465 runner->Run(); |
1467 | 1466 |
1468 // Verify callback was called with correct status. | 1467 // Verify callback was called with correct status. |
1469 EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status); | 1468 EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status); |
1470 } | 1469 } |
1471 | 1470 |
1472 } // namespace content | 1471 } // namespace content |
OLD | NEW |