Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(183)

Side by Side Diff: content/browser/service_worker/service_worker_version_unittest.cc

Issue 2039743003: Introduce ServiceWorker.ActivatedWorkerPreparationForMainFrame.Time UMA. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « content/browser/service_worker/service_worker_version.cc ('k') | content/content_browser.gypi » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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
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
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
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
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
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
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
OLDNEW
« no previous file with comments | « content/browser/service_worker/service_worker_version.cc ('k') | content/content_browser.gypi » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698