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/embedded_worker_test_helper.h" | 5 #include "content/browser/service_worker/embedded_worker_test_helper.h" |
6 | 6 |
7 #include <map> | 7 #include <map> |
8 #include <memory> | 8 #include <memory> |
9 #include <string> | 9 #include <string> |
10 #include <utility> | 10 #include <utility> |
11 #include <vector> | 11 #include <vector> |
12 | 12 |
13 #include "base/atomic_sequence_num.h" | 13 #include "base/atomic_sequence_num.h" |
14 #include "base/bind.h" | 14 #include "base/bind.h" |
15 #include "base/memory/ptr_util.h" | 15 #include "base/memory/ptr_util.h" |
16 #include "base/message_loop/message_loop.h" | |
17 #include "base/run_loop.h" | |
16 #include "base/threading/thread_task_runner_handle.h" | 18 #include "base/threading/thread_task_runner_handle.h" |
17 #include "base/time/time.h" | 19 #include "base/time/time.h" |
18 #include "content/browser/service_worker/embedded_worker_instance.h" | 20 #include "content/browser/service_worker/embedded_worker_instance.h" |
19 #include "content/browser/service_worker/embedded_worker_registry.h" | 21 #include "content/browser/service_worker/embedded_worker_registry.h" |
20 #include "content/browser/service_worker/embedded_worker_status.h" | 22 #include "content/browser/service_worker/embedded_worker_status.h" |
21 #include "content/browser/service_worker/service_worker_context_core.h" | 23 #include "content/browser/service_worker/service_worker_context_core.h" |
22 #include "content/browser/service_worker/service_worker_context_wrapper.h" | 24 #include "content/browser/service_worker/service_worker_context_wrapper.h" |
23 #include "content/browser/service_worker/service_worker_dispatcher_host.h" | 25 #include "content/browser/service_worker/service_worker_dispatcher_host.h" |
26 #include "content/browser/service_worker/service_worker_test_utils.h" | |
24 #include "content/common/background_fetch/background_fetch_types.h" | 27 #include "content/common/background_fetch/background_fetch_types.h" |
25 #include "content/common/service_worker/embedded_worker_messages.h" | 28 #include "content/common/service_worker/embedded_worker_messages.h" |
26 #include "content/common/service_worker/embedded_worker_start_params.h" | 29 #include "content/common/service_worker/embedded_worker_start_params.h" |
27 #include "content/common/service_worker/service_worker_messages.h" | 30 #include "content/common/service_worker/service_worker_messages.h" |
28 #include "content/common/service_worker/service_worker_utils.h" | 31 #include "content/common/service_worker/service_worker_utils.h" |
29 #include "content/public/common/push_event_payload.h" | 32 #include "content/public/common/push_event_payload.h" |
30 #include "content/public/test/mock_render_process_host.h" | 33 #include "content/public/test/mock_render_process_host.h" |
31 #include "content/public/test/test_browser_context.h" | 34 #include "content/public/test/test_browser_context.h" |
32 #include "mojo/public/cpp/bindings/interface_request.h" | 35 #include "mojo/public/cpp/bindings/interface_request.h" |
33 #include "mojo/public/cpp/bindings/strong_binding.h" | 36 #include "mojo/public/cpp/bindings/strong_binding.h" |
(...skipping 30 matching lines...) Expand all Loading... | |
64 EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient:: | 67 EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient:: |
65 MockEmbeddedWorkerInstanceClient( | 68 MockEmbeddedWorkerInstanceClient( |
66 base::WeakPtr<EmbeddedWorkerTestHelper> helper) | 69 base::WeakPtr<EmbeddedWorkerTestHelper> helper) |
67 : helper_(helper), binding_(this) {} | 70 : helper_(helper), binding_(this) {} |
68 | 71 |
69 EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient:: | 72 EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient:: |
70 ~MockEmbeddedWorkerInstanceClient() {} | 73 ~MockEmbeddedWorkerInstanceClient() {} |
71 | 74 |
72 void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::StartWorker( | 75 void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::StartWorker( |
73 const EmbeddedWorkerStartParams& params, | 76 const EmbeddedWorkerStartParams& params, |
74 mojom::ServiceWorkerEventDispatcherRequest dispatcher_request) { | 77 mojom::ServiceWorkerEventDispatcherRequest dispatcher_request, |
78 mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo instance_host) { | |
75 if (!helper_) | 79 if (!helper_) |
76 return; | 80 return; |
77 | 81 |
78 embedded_worker_id_ = params.embedded_worker_id; | 82 embedded_worker_id_ = params.embedded_worker_id; |
79 | 83 |
80 EmbeddedWorkerInstance* worker = | 84 EmbeddedWorkerInstance* worker = |
81 helper_->registry()->GetWorker(params.embedded_worker_id); | 85 helper_->registry()->GetWorker(params.embedded_worker_id); |
82 ASSERT_TRUE(worker); | 86 ASSERT_TRUE(worker); |
83 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); | 87 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); |
84 | 88 |
85 helper_->OnStartWorkerStub(params, std::move(dispatcher_request)); | 89 helper_->OnStartWorkerStub(params, std::move(dispatcher_request), |
90 std::move(instance_host)); | |
86 } | 91 } |
87 | 92 |
88 void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::StopWorker( | 93 void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::StopWorker() { |
89 const StopWorkerCallback& callback) { | |
90 if (!helper_) | 94 if (!helper_) |
91 return; | 95 return; |
92 | 96 |
93 ASSERT_TRUE(embedded_worker_id_); | 97 ASSERT_TRUE(embedded_worker_id_); |
94 EmbeddedWorkerInstance* worker = | 98 EmbeddedWorkerInstance* worker = |
95 helper_->registry()->GetWorker(embedded_worker_id_.value()); | 99 helper_->registry()->GetWorker(embedded_worker_id_.value()); |
96 // |worker| is possible to be null when corresponding EmbeddedWorkerInstance | 100 // |worker| is possible to be null when corresponding EmbeddedWorkerInstance |
97 // is removed right after sending StopWorker. | 101 // is removed right after sending StopWorker. |
98 if (worker) | 102 if (worker) |
99 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, worker->status()); | 103 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, worker->status()); |
100 helper_->OnStopWorkerStub(callback); | 104 helper_->OnStopWorkerStub(embedded_worker_id_.value()); |
101 } | 105 } |
102 | 106 |
103 void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient:: | 107 void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient:: |
104 ResumeAfterDownload() { | 108 ResumeAfterDownload() { |
105 helper_->OnResumeAfterDownloadStub(embedded_worker_id_.value()); | 109 helper_->OnResumeAfterDownloadStub(embedded_worker_id_.value()); |
106 } | 110 } |
107 | 111 |
108 void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient:: | 112 void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient:: |
109 AddMessageToConsole(blink::WebConsoleMessage::Level level, | 113 AddMessageToConsole(blink::WebConsoleMessage::Level level, |
110 const std::string& message) { | 114 const std::string& message) { |
(...skipping 159 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
270 | 274 |
271 EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper( | 275 EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper( |
272 const base::FilePath& user_data_directory) | 276 const base::FilePath& user_data_directory) |
273 : browser_context_(new TestBrowserContext), | 277 : browser_context_(new TestBrowserContext), |
274 render_process_host_(new MockRenderProcessHost(browser_context_.get())), | 278 render_process_host_(new MockRenderProcessHost(browser_context_.get())), |
275 new_render_process_host_( | 279 new_render_process_host_( |
276 new MockRenderProcessHost(browser_context_.get())), | 280 new MockRenderProcessHost(browser_context_.get())), |
277 wrapper_(new ServiceWorkerContextWrapper(browser_context_.get())), | 281 wrapper_(new ServiceWorkerContextWrapper(browser_context_.get())), |
278 mock_instance_clients_next_index_(0), | 282 mock_instance_clients_next_index_(0), |
279 next_thread_id_(0), | 283 next_thread_id_(0), |
284 next_provider_id_(1000), | |
280 mock_render_process_id_(render_process_host_->GetID()), | 285 mock_render_process_id_(render_process_host_->GetID()), |
281 new_mock_render_process_id_(new_render_process_host_->GetID()), | 286 new_mock_render_process_id_(new_render_process_host_->GetID()), |
282 weak_factory_(this) { | 287 weak_factory_(this) { |
283 std::unique_ptr<MockServiceWorkerDatabaseTaskManager> database_task_manager( | 288 std::unique_ptr<MockServiceWorkerDatabaseTaskManager> database_task_manager( |
284 new MockServiceWorkerDatabaseTaskManager( | 289 new MockServiceWorkerDatabaseTaskManager( |
285 base::ThreadTaskRunnerHandle::Get())); | 290 base::ThreadTaskRunnerHandle::Get())); |
286 wrapper_->InitInternal(user_data_directory, std::move(database_task_manager), | 291 wrapper_->InitInternal(user_data_directory, std::move(database_task_manager), |
287 base::ThreadTaskRunnerHandle::Get(), nullptr, nullptr); | 292 base::ThreadTaskRunnerHandle::Get(), nullptr, nullptr); |
288 wrapper_->process_manager()->SetProcessIdForTest(mock_render_process_id()); | 293 wrapper_->process_manager()->SetProcessIdForTest(mock_render_process_id()); |
289 wrapper_->process_manager()->SetNewProcessIdForTest(new_render_process_id()); | 294 wrapper_->process_manager()->SetNewProcessIdForTest(new_render_process_id()); |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
368 new net::HttpResponseHeaders(std::string(data, arraysize(data))); | 373 new net::HttpResponseHeaders(std::string(data, arraysize(data))); |
369 return info; | 374 return info; |
370 } | 375 } |
371 | 376 |
372 void EmbeddedWorkerTestHelper::OnStartWorker( | 377 void EmbeddedWorkerTestHelper::OnStartWorker( |
373 int embedded_worker_id, | 378 int embedded_worker_id, |
374 int64_t service_worker_version_id, | 379 int64_t service_worker_version_id, |
375 const GURL& scope, | 380 const GURL& scope, |
376 const GURL& script_url, | 381 const GURL& script_url, |
377 bool pause_after_download, | 382 bool pause_after_download, |
378 mojom::ServiceWorkerEventDispatcherRequest request) { | 383 mojom::ServiceWorkerEventDispatcherRequest request, |
384 mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo instance_host) { | |
379 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); | 385 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); |
380 ASSERT_TRUE(worker); | 386 ASSERT_TRUE(worker); |
381 MockServiceWorkerEventDispatcher::Create(AsWeakPtr(), worker->thread_id(), | 387 MockServiceWorkerEventDispatcher::Create(AsWeakPtr(), worker->thread_id(), |
382 std::move(request)); | 388 std::move(request)); |
383 | 389 |
384 embedded_worker_id_service_worker_version_id_map_[embedded_worker_id] = | 390 embedded_worker_id_service_worker_version_id_map_[embedded_worker_id] = |
385 service_worker_version_id; | 391 service_worker_version_id; |
392 embedded_worker_id_instance_host_ptr_map_[embedded_worker_id].Bind( | |
393 std::move(instance_host)); | |
394 | |
386 SimulateWorkerReadyForInspection(embedded_worker_id); | 395 SimulateWorkerReadyForInspection(embedded_worker_id); |
387 SimulateWorkerScriptCached(embedded_worker_id); | 396 SimulateWorkerScriptCached(embedded_worker_id); |
388 SimulateWorkerScriptLoaded(embedded_worker_id); | 397 SimulateWorkerScriptLoaded(embedded_worker_id); |
389 if (!pause_after_download) | 398 if (!pause_after_download) |
390 OnResumeAfterDownload(embedded_worker_id); | 399 OnResumeAfterDownload(embedded_worker_id); |
391 } | 400 } |
392 | 401 |
393 void EmbeddedWorkerTestHelper::OnResumeAfterDownload(int embedded_worker_id) { | 402 void EmbeddedWorkerTestHelper::OnResumeAfterDownload(int embedded_worker_id) { |
394 SimulateWorkerThreadStarted(GetNextThreadId(), embedded_worker_id); | 403 SimulateWorkerThreadStarted(GetNextThreadId(), embedded_worker_id, |
404 GetNextProviderId()); | |
395 SimulateWorkerScriptEvaluated(embedded_worker_id, true /* success */); | 405 SimulateWorkerScriptEvaluated(embedded_worker_id, true /* success */); |
396 SimulateWorkerStarted(embedded_worker_id); | 406 SimulateWorkerStarted(embedded_worker_id); |
397 } | 407 } |
398 | 408 |
399 void EmbeddedWorkerTestHelper::OnStopWorker( | 409 void EmbeddedWorkerTestHelper::OnStopWorker(int embedded_worker_id) { |
400 const mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback& callback) { | |
401 // By default just notify the sender that the worker is stopped. | 410 // By default just notify the sender that the worker is stopped. |
402 callback.Run(); | 411 SimulateWorkerStopped(embedded_worker_id); |
403 } | 412 } |
404 | 413 |
405 bool EmbeddedWorkerTestHelper::OnMessageToWorker(int thread_id, | 414 bool EmbeddedWorkerTestHelper::OnMessageToWorker(int thread_id, |
406 int embedded_worker_id, | 415 int embedded_worker_id, |
407 const IPC::Message& message) { | 416 const IPC::Message& message) { |
408 bool handled = true; | 417 bool handled = true; |
409 current_embedded_worker_id_ = embedded_worker_id; | 418 current_embedded_worker_id_ = embedded_worker_id; |
410 IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message) | 419 IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message) |
411 IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEventStub) | 420 IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEventStub) |
412 IPC_MESSAGE_UNHANDLED(handled = false) | 421 IPC_MESSAGE_UNHANDLED(handled = false) |
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
525 DispatchPaymentRequestEventCallback& callback) { | 534 DispatchPaymentRequestEventCallback& callback) { |
526 response_callback->OnPaymentAppResponse( | 535 response_callback->OnPaymentAppResponse( |
527 payments::mojom::PaymentAppResponse::New(), base::Time::Now()); | 536 payments::mojom::PaymentAppResponse::New(), base::Time::Now()); |
528 callback.Run(SERVICE_WORKER_OK, base::Time::Now()); | 537 callback.Run(SERVICE_WORKER_OK, base::Time::Now()); |
529 } | 538 } |
530 | 539 |
531 void EmbeddedWorkerTestHelper::SimulateWorkerReadyForInspection( | 540 void EmbeddedWorkerTestHelper::SimulateWorkerReadyForInspection( |
532 int embedded_worker_id) { | 541 int embedded_worker_id) { |
533 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); | 542 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); |
534 ASSERT_TRUE(worker); | 543 ASSERT_TRUE(worker); |
535 registry()->OnWorkerReadyForInspection(worker->process_id(), | 544 ASSERT_TRUE(embedded_worker_id_instance_host_ptr_map_[embedded_worker_id]); |
536 embedded_worker_id); | 545 embedded_worker_id_instance_host_ptr_map_[embedded_worker_id] |
546 ->OnReadyForInspection(); | |
547 base::RunLoop().RunUntilIdle(); | |
537 } | 548 } |
538 | 549 |
539 void EmbeddedWorkerTestHelper::SimulateWorkerScriptCached( | 550 void EmbeddedWorkerTestHelper::SimulateWorkerScriptCached( |
540 int embedded_worker_id) { | 551 int embedded_worker_id) { |
541 int64_t version_id = | 552 int64_t version_id = |
542 embedded_worker_id_service_worker_version_id_map_[embedded_worker_id]; | 553 embedded_worker_id_service_worker_version_id_map_[embedded_worker_id]; |
543 ServiceWorkerVersion* version = context()->GetLiveVersion(version_id); | 554 ServiceWorkerVersion* version = context()->GetLiveVersion(version_id); |
544 if (!version) | 555 if (!version) |
545 return; | 556 return; |
546 if (!version->script_cache_map()->size()) { | 557 if (!version->script_cache_map()->size()) { |
547 std::vector<ServiceWorkerDatabase::ResourceRecord> records; | 558 std::vector<ServiceWorkerDatabase::ResourceRecord> records; |
548 // Add a dummy ResourceRecord for the main script to the script cache map of | 559 // Add a dummy ResourceRecord for the main script to the script cache map of |
549 // the ServiceWorkerVersion. We use embedded_worker_id for resource_id to | 560 // the ServiceWorkerVersion. We use embedded_worker_id for resource_id to |
550 // avoid ID collision. | 561 // avoid ID collision. |
551 records.push_back(ServiceWorkerDatabase::ResourceRecord( | 562 records.push_back(ServiceWorkerDatabase::ResourceRecord( |
552 embedded_worker_id, version->script_url(), 100)); | 563 embedded_worker_id, version->script_url(), 100)); |
553 version->script_cache_map()->SetResources(records); | 564 version->script_cache_map()->SetResources(records); |
554 } | 565 } |
555 if (!version->GetMainScriptHttpResponseInfo()) | 566 if (!version->GetMainScriptHttpResponseInfo()) |
556 version->SetMainScriptHttpResponseInfo(CreateHttpResponseInfo()); | 567 version->SetMainScriptHttpResponseInfo(CreateHttpResponseInfo()); |
557 } | 568 } |
558 | 569 |
559 void EmbeddedWorkerTestHelper::SimulateWorkerScriptLoaded( | 570 void EmbeddedWorkerTestHelper::SimulateWorkerScriptLoaded( |
560 int embedded_worker_id) { | 571 int embedded_worker_id) { |
561 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); | 572 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); |
562 ASSERT_TRUE(worker); | 573 ASSERT_TRUE(worker); |
563 registry()->OnWorkerScriptLoaded(worker->process_id(), embedded_worker_id); | 574 ASSERT_TRUE(embedded_worker_id_instance_host_ptr_map_[embedded_worker_id]); |
575 embedded_worker_id_instance_host_ptr_map_[embedded_worker_id] | |
576 ->OnScriptLoaded(); | |
577 base::RunLoop().RunUntilIdle(); | |
564 } | 578 } |
565 | 579 |
566 void EmbeddedWorkerTestHelper::SimulateWorkerThreadStarted( | 580 void EmbeddedWorkerTestHelper::SimulateWorkerThreadStarted( |
567 int thread_id, | 581 int thread_id, |
568 int embedded_worker_id) { | 582 int embedded_worker_id, |
569 thread_id_embedded_worker_id_map_[thread_id] = embedded_worker_id; | 583 int provider_id) { |
570 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); | 584 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); |
571 ASSERT_TRUE(worker); | 585 ASSERT_TRUE(worker); |
572 registry()->OnWorkerThreadStarted(worker->process_id(), thread_id, | 586 // Prepare a provider host to be used by following OnThreadStarted(). |
573 embedded_worker_id); | 587 auto host = CreateProviderHostForServiceWorkerContext( |
shimazu
2017/04/11 04:32:40
Could you use std::unique_ptr<ServiceWorkerProvide
leonhsl(Using Gerrit)
2017/04/11 05:52:28
Done.
| |
588 worker->process_id(), provider_id, true /* is_parent_frame_secure */, | |
589 context()->AsWeakPtr()); | |
590 context()->AddProviderHost(std::move(host)); | |
591 | |
592 ASSERT_TRUE(embedded_worker_id_instance_host_ptr_map_[embedded_worker_id]); | |
593 embedded_worker_id_instance_host_ptr_map_[embedded_worker_id] | |
594 ->OnThreadStarted(thread_id, provider_id); | |
595 base::RunLoop().RunUntilIdle(); | |
574 } | 596 } |
575 | 597 |
576 void EmbeddedWorkerTestHelper::SimulateWorkerScriptEvaluated( | 598 void EmbeddedWorkerTestHelper::SimulateWorkerScriptEvaluated( |
577 int embedded_worker_id, | 599 int embedded_worker_id, |
578 bool success) { | 600 bool success) { |
579 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); | 601 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); |
580 ASSERT_TRUE(worker); | 602 ASSERT_TRUE(worker); |
581 registry()->OnWorkerScriptEvaluated(worker->process_id(), embedded_worker_id, | 603 ASSERT_TRUE(embedded_worker_id_instance_host_ptr_map_[embedded_worker_id]); |
582 success); | 604 embedded_worker_id_instance_host_ptr_map_[embedded_worker_id] |
605 ->OnScriptEvaluated(success); | |
606 base::RunLoop().RunUntilIdle(); | |
583 } | 607 } |
584 | 608 |
585 void EmbeddedWorkerTestHelper::SimulateWorkerStarted(int embedded_worker_id) { | 609 void EmbeddedWorkerTestHelper::SimulateWorkerStarted(int embedded_worker_id) { |
586 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); | 610 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); |
587 ASSERT_TRUE(worker); | 611 ASSERT_TRUE(worker); |
588 registry()->OnWorkerStarted(worker->process_id(), embedded_worker_id); | 612 ASSERT_TRUE(embedded_worker_id_instance_host_ptr_map_[embedded_worker_id]); |
613 embedded_worker_id_instance_host_ptr_map_[embedded_worker_id]->OnStarted(); | |
614 base::RunLoop().RunUntilIdle(); | |
589 } | 615 } |
590 | 616 |
591 void EmbeddedWorkerTestHelper::SimulateWorkerStopped(int embedded_worker_id) { | 617 void EmbeddedWorkerTestHelper::SimulateWorkerStopped(int embedded_worker_id) { |
592 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); | 618 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); |
593 if (worker) | 619 if (worker) { |
594 registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id); | 620 ASSERT_TRUE(embedded_worker_id_instance_host_ptr_map_[embedded_worker_id]); |
621 embedded_worker_id_instance_host_ptr_map_[embedded_worker_id]->OnStopped(); | |
622 base::RunLoop().RunUntilIdle(); | |
623 } | |
595 } | 624 } |
596 | 625 |
597 void EmbeddedWorkerTestHelper::SimulateSend(IPC::Message* message) { | 626 void EmbeddedWorkerTestHelper::SimulateSend(IPC::Message* message) { |
598 registry()->OnMessageReceived(*message, mock_render_process_id_); | 627 registry()->OnMessageReceived(*message, mock_render_process_id_); |
599 delete message; | 628 delete message; |
600 } | 629 } |
601 | 630 |
602 void EmbeddedWorkerTestHelper::OnStartWorkerStub( | 631 void EmbeddedWorkerTestHelper::OnStartWorkerStub( |
603 const EmbeddedWorkerStartParams& params, | 632 const EmbeddedWorkerStartParams& params, |
604 mojom::ServiceWorkerEventDispatcherRequest request) { | 633 mojom::ServiceWorkerEventDispatcherRequest request, |
634 mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo instance_host) { | |
605 EmbeddedWorkerInstance* worker = | 635 EmbeddedWorkerInstance* worker = |
606 registry()->GetWorker(params.embedded_worker_id); | 636 registry()->GetWorker(params.embedded_worker_id); |
607 ASSERT_TRUE(worker); | 637 ASSERT_TRUE(worker); |
608 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); | 638 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); |
609 base::ThreadTaskRunnerHandle::Get()->PostTask( | 639 base::ThreadTaskRunnerHandle::Get()->PostTask( |
610 FROM_HERE, | 640 FROM_HERE, |
611 base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker, AsWeakPtr(), | 641 base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker, AsWeakPtr(), |
612 params.embedded_worker_id, params.service_worker_version_id, | 642 params.embedded_worker_id, params.service_worker_version_id, |
613 params.scope, params.script_url, params.pause_after_download, | 643 params.scope, params.script_url, params.pause_after_download, |
614 base::Passed(&request))); | 644 base::Passed(&request), base::Passed(&instance_host))); |
615 } | 645 } |
616 | 646 |
617 void EmbeddedWorkerTestHelper::OnResumeAfterDownloadStub( | 647 void EmbeddedWorkerTestHelper::OnResumeAfterDownloadStub( |
618 int embedded_worker_id) { | 648 int embedded_worker_id) { |
619 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); | 649 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); |
620 ASSERT_TRUE(worker); | 650 ASSERT_TRUE(worker); |
621 base::ThreadTaskRunnerHandle::Get()->PostTask( | 651 base::ThreadTaskRunnerHandle::Get()->PostTask( |
622 FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnResumeAfterDownload, | 652 FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnResumeAfterDownload, |
623 AsWeakPtr(), embedded_worker_id)); | 653 AsWeakPtr(), embedded_worker_id)); |
624 } | 654 } |
625 | 655 |
626 void EmbeddedWorkerTestHelper::OnStopWorkerStub( | 656 void EmbeddedWorkerTestHelper::OnStopWorkerStub(int embedded_worker_id) { |
627 const mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback& callback) { | |
628 base::ThreadTaskRunnerHandle::Get()->PostTask( | 657 base::ThreadTaskRunnerHandle::Get()->PostTask( |
629 FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnStopWorker, | 658 FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnStopWorker, |
630 AsWeakPtr(), callback)); | 659 AsWeakPtr(), embedded_worker_id)); |
631 } | 660 } |
632 | 661 |
633 void EmbeddedWorkerTestHelper::OnMessageToWorkerStub( | 662 void EmbeddedWorkerTestHelper::OnMessageToWorkerStub( |
634 int thread_id, | 663 int thread_id, |
635 int embedded_worker_id, | 664 int embedded_worker_id, |
636 const IPC::Message& message) { | 665 const IPC::Message& message) { |
637 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); | 666 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); |
638 ASSERT_TRUE(worker); | 667 ASSERT_TRUE(worker); |
639 EXPECT_EQ(worker->thread_id(), thread_id); | 668 EXPECT_EQ(worker->thread_id(), thread_id); |
640 base::ThreadTaskRunnerHandle::Get()->PostTask( | 669 base::ThreadTaskRunnerHandle::Get()->PostTask( |
(...skipping 126 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
767 base::Passed(std::move(app_request)), | 796 base::Passed(std::move(app_request)), |
768 base::Passed(std::move(response_callback)), callback)); | 797 base::Passed(std::move(response_callback)), callback)); |
769 } | 798 } |
770 | 799 |
771 EmbeddedWorkerRegistry* EmbeddedWorkerTestHelper::registry() { | 800 EmbeddedWorkerRegistry* EmbeddedWorkerTestHelper::registry() { |
772 DCHECK(context()); | 801 DCHECK(context()); |
773 return context()->embedded_worker_registry(); | 802 return context()->embedded_worker_registry(); |
774 } | 803 } |
775 | 804 |
776 } // namespace content | 805 } // namespace content |
OLD | NEW |