OLD | NEW |
---|---|
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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_instance.h" | 5 #include "content/browser/service_worker/embedded_worker_instance.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 #include <utility> | 8 #include <utility> |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
(...skipping 26 matching lines...) Expand all Loading... | |
37 | 37 |
38 void SaveStatusAndCall(ServiceWorkerStatusCode* out, | 38 void SaveStatusAndCall(ServiceWorkerStatusCode* out, |
39 const base::Closure& callback, | 39 const base::Closure& callback, |
40 ServiceWorkerStatusCode status) { | 40 ServiceWorkerStatusCode status) { |
41 *out = status; | 41 *out = status; |
42 callback.Run(); | 42 callback.Run(); |
43 } | 43 } |
44 | 44 |
45 } // namespace | 45 } // namespace |
46 | 46 |
47 class ProviderHostEndpoints : public mojom::ServiceWorkerProviderHost { | |
48 public: | |
49 ProviderHostEndpoints() : binding_(this) {} | |
50 | |
51 ~ProviderHostEndpoints() override {} | |
52 | |
53 mojom::ServiceWorkerProviderInfoForStartWorkerPtr | |
54 CreateProviderClientInfoPtr() { | |
55 DCHECK(!binding_.is_bound()); | |
56 DCHECK(!client_.is_bound()); | |
57 // Just keep the endpoints. | |
58 mojom::ServiceWorkerProviderInfoForStartWorkerPtr provider_info = | |
59 mojom::ServiceWorkerProviderInfoForStartWorker::New(); | |
60 binding_.Bind(mojo::MakeRequest(&provider_info->host_ptr_info)); | |
61 provider_info->client_request = mojo::MakeRequest(&client_); | |
62 return provider_info; | |
63 } | |
64 | |
65 private: | |
66 mojom::ServiceWorkerProviderAssociatedPtr client_; | |
67 mojo::AssociatedBinding<mojom::ServiceWorkerProviderHost> binding_; | |
68 | |
69 DISALLOW_COPY_AND_ASSIGN(ProviderHostEndpoints); | |
70 }; | |
71 | |
47 class EmbeddedWorkerInstanceTest : public testing::Test, | 72 class EmbeddedWorkerInstanceTest : public testing::Test, |
48 public EmbeddedWorkerInstance::Listener { | 73 public EmbeddedWorkerInstance::Listener { |
49 protected: | 74 protected: |
50 EmbeddedWorkerInstanceTest() | 75 EmbeddedWorkerInstanceTest() |
51 : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} | 76 : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} |
52 | 77 |
53 enum EventType { | 78 enum EventType { |
54 PROCESS_ALLOCATED, | 79 PROCESS_ALLOCATED, |
55 START_WORKER_MESSAGE_SENT, | 80 START_WORKER_MESSAGE_SENT, |
56 STARTED, | 81 STARTED, |
(...skipping 18 matching lines...) Expand all Loading... | |
75 RecordEvent(START_WORKER_MESSAGE_SENT); | 100 RecordEvent(START_WORKER_MESSAGE_SENT); |
76 } | 101 } |
77 void OnStarted() override { RecordEvent(STARTED); } | 102 void OnStarted() override { RecordEvent(STARTED); } |
78 void OnStopped(EmbeddedWorkerStatus old_status) override { | 103 void OnStopped(EmbeddedWorkerStatus old_status) override { |
79 RecordEvent(STOPPED, old_status); | 104 RecordEvent(STOPPED, old_status); |
80 } | 105 } |
81 void OnDetached(EmbeddedWorkerStatus old_status) override { | 106 void OnDetached(EmbeddedWorkerStatus old_status) override { |
82 RecordEvent(DETACHED, old_status); | 107 RecordEvent(DETACHED, old_status); |
83 } | 108 } |
84 | 109 |
85 bool OnMessageReceived(const IPC::Message& message) override { return false; } | 110 bool OnMessageReceived(const IPC::Message&) override { return false; } |
86 | 111 |
87 void SetUp() override { | 112 void SetUp() override { |
88 helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath())); | 113 helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath())); |
89 } | 114 } |
90 | 115 |
91 void TearDown() override { helper_.reset(); } | 116 void TearDown() override { helper_.reset(); } |
92 | 117 |
93 ServiceWorkerStatusCode StartWorker(EmbeddedWorkerInstance* worker, | 118 ServiceWorkerStatusCode StartWorker(EmbeddedWorkerInstance* worker, |
94 int id, const GURL& pattern, | 119 int id, const GURL& pattern, |
95 const GURL& url) { | 120 const GURL& url) { |
96 ServiceWorkerStatusCode status; | 121 ServiceWorkerStatusCode status; |
97 base::RunLoop run_loop; | 122 base::RunLoop run_loop; |
98 std::unique_ptr<EmbeddedWorkerStartParams> params = | 123 std::unique_ptr<EmbeddedWorkerStartParams> params = |
99 CreateStartParams(id, pattern, url); | 124 CreateStartParams(id, pattern, url); |
100 worker->Start( | 125 worker->Start( |
101 std::move(params), CreateEventDispatcher(), | 126 std::move(params), CreateProviderClientInfoGetter(), |
falken
2017/06/19 07:50:40
CreateProviderInfoGetter
shimazu
2017/06/19 10:41:25
Done.
| |
127 CreateEventDispatcher(), | |
102 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); | 128 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
103 run_loop.Run(); | 129 run_loop.Run(); |
104 return status; | 130 return status; |
105 } | 131 } |
106 | 132 |
107 std::unique_ptr<EmbeddedWorkerStartParams> | 133 std::unique_ptr<EmbeddedWorkerStartParams> |
108 CreateStartParams(int version_id, const GURL& scope, const GURL& script_url) { | 134 CreateStartParams(int version_id, const GURL& scope, const GURL& script_url) { |
109 std::unique_ptr<EmbeddedWorkerStartParams> params = | 135 std::unique_ptr<EmbeddedWorkerStartParams> params = |
110 base::MakeUnique<EmbeddedWorkerStartParams>(); | 136 base::MakeUnique<EmbeddedWorkerStartParams>(); |
111 params->service_worker_version_id = version_id; | 137 params->service_worker_version_id = version_id; |
112 params->scope = scope; | 138 params->scope = scope; |
113 params->script_url = script_url; | 139 params->script_url = script_url; |
114 params->pause_after_download = false; | 140 params->pause_after_download = false; |
115 params->is_installed = false; | 141 params->is_installed = false; |
116 return params; | 142 return params; |
117 } | 143 } |
118 | 144 |
145 mojom::ServiceWorkerProviderInfoForStartWorkerPtr CreateProviderClientInfo( | |
falken
2017/06/19 07:50:40
rename
shimazu
2017/06/19 10:41:25
Done.
| |
146 int /* process_id */) { | |
147 provider_host_endpoints_.emplace_back( | |
148 base::MakeUnique<ProviderHostEndpoints>()); | |
149 return provider_host_endpoints_.back()->CreateProviderClientInfoPtr(); | |
150 } | |
151 | |
152 EmbeddedWorkerInstance::ProviderClientInfoGetter | |
153 CreateProviderClientInfoGetter() { | |
154 return base::BindOnce(&EmbeddedWorkerInstanceTest::CreateProviderClientInfo, | |
155 base::Unretained(this)); | |
156 } | |
157 | |
119 mojom::ServiceWorkerEventDispatcherRequest CreateEventDispatcher() { | 158 mojom::ServiceWorkerEventDispatcherRequest CreateEventDispatcher() { |
120 dispatchers_.emplace_back(); | 159 dispatchers_.emplace_back(); |
121 return mojo::MakeRequest(&dispatchers_.back()); | 160 return mojo::MakeRequest(&dispatchers_.back()); |
122 } | 161 } |
123 | 162 |
124 ServiceWorkerContextCore* context() { return helper_->context(); } | 163 ServiceWorkerContextCore* context() { return helper_->context(); } |
125 | 164 |
126 EmbeddedWorkerRegistry* embedded_worker_registry() { | 165 EmbeddedWorkerRegistry* embedded_worker_registry() { |
127 DCHECK(context()); | 166 DCHECK(context()); |
128 return context()->embedded_worker_registry(); | 167 return context()->embedded_worker_registry(); |
129 } | 168 } |
130 | 169 |
131 IPC::TestSink* ipc_sink() { return helper_->ipc_sink(); } | 170 IPC::TestSink* ipc_sink() { return helper_->ipc_sink(); } |
132 | 171 |
133 std::vector<std::unique_ptr< | 172 std::vector<std::unique_ptr< |
134 EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient>>* | 173 EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient>>* |
135 mock_instance_clients() { | 174 mock_instance_clients() { |
136 return helper_->mock_instance_clients(); | 175 return helper_->mock_instance_clients(); |
137 } | 176 } |
138 | 177 |
139 std::vector<mojom::ServiceWorkerEventDispatcherPtr> dispatchers_; | 178 std::vector<mojom::ServiceWorkerEventDispatcherPtr> dispatchers_; |
179 std::vector<std::unique_ptr<ProviderHostEndpoints>> provider_host_endpoints_; | |
140 | 180 |
141 TestBrowserThreadBundle thread_bundle_; | 181 TestBrowserThreadBundle thread_bundle_; |
142 std::unique_ptr<EmbeddedWorkerTestHelper> helper_; | 182 std::unique_ptr<EmbeddedWorkerTestHelper> helper_; |
143 std::vector<EventLog> events_; | 183 std::vector<EventLog> events_; |
144 | 184 |
145 private: | 185 private: |
146 DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerInstanceTest); | 186 DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerInstanceTest); |
147 }; | 187 }; |
148 | 188 |
149 // A helper to simulate the start worker sequence is stalled in a worker | 189 // A helper to simulate the start worker sequence is stalled in a worker |
150 // process. | 190 // process. |
151 class StalledInStartWorkerHelper : public EmbeddedWorkerTestHelper { | 191 class StalledInStartWorkerHelper : public EmbeddedWorkerTestHelper { |
152 public: | 192 public: |
153 StalledInStartWorkerHelper() : EmbeddedWorkerTestHelper(base::FilePath()) {} | 193 StalledInStartWorkerHelper() : EmbeddedWorkerTestHelper(base::FilePath()) {} |
154 ~StalledInStartWorkerHelper() override {} | 194 ~StalledInStartWorkerHelper() override {} |
155 | 195 |
156 void OnStartWorker(int embedded_worker_id, | 196 void OnStartWorker( |
157 int64_t service_worker_version_id, | 197 int embedded_worker_id, |
158 const GURL& scope, | 198 int64_t service_worker_version_id, |
159 const GURL& script_url, | 199 const GURL& scope, |
160 bool pause_after_download, | 200 const GURL& script_url, |
161 mojom::ServiceWorkerEventDispatcherRequest request, | 201 bool pause_after_download, |
162 mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo | 202 mojom::ServiceWorkerEventDispatcherRequest request, |
163 instance_host) override { | 203 mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo instance_host, |
204 mojom::ServiceWorkerProviderInfoForStartWorkerPtr provider_info) | |
205 override { | |
164 if (force_stall_in_start_) { | 206 if (force_stall_in_start_) { |
165 // Prepare for OnStopWorker(). | 207 // Prepare for OnStopWorker(). |
166 instance_host_ptr_map_[embedded_worker_id].Bind(std::move(instance_host)); | 208 instance_host_ptr_map_[embedded_worker_id].Bind(std::move(instance_host)); |
167 // Do nothing to simulate a stall in the worker process. | 209 // Do nothing to simulate a stall in the worker process. |
168 return; | 210 return; |
169 } | 211 } |
170 EmbeddedWorkerTestHelper::OnStartWorker( | 212 EmbeddedWorkerTestHelper::OnStartWorker( |
171 embedded_worker_id, service_worker_version_id, scope, script_url, | 213 embedded_worker_id, service_worker_version_id, scope, script_url, |
172 pause_after_download, std::move(request), std::move(instance_host)); | 214 pause_after_download, std::move(request), std::move(instance_host), |
215 std::move(provider_info)); | |
173 } | 216 } |
174 | 217 |
175 void OnStopWorker(int embedded_worker_id) override { | 218 void OnStopWorker(int embedded_worker_id) override { |
176 if (instance_host_ptr_map_[embedded_worker_id]) { | 219 if (instance_host_ptr_map_[embedded_worker_id]) { |
177 instance_host_ptr_map_[embedded_worker_id]->OnStopped(); | 220 instance_host_ptr_map_[embedded_worker_id]->OnStopped(); |
178 base::RunLoop().RunUntilIdle(); | 221 base::RunLoop().RunUntilIdle(); |
179 return; | 222 return; |
180 } | 223 } |
181 EmbeddedWorkerTestHelper::OnStopWorker(embedded_worker_id); | 224 EmbeddedWorkerTestHelper::OnStopWorker(embedded_worker_id); |
182 } | 225 } |
(...skipping 24 matching lines...) Expand all Loading... | |
207 // Simulate adding one process to the pattern. | 250 // Simulate adding one process to the pattern. |
208 helper_->SimulateAddProcessToPattern(pattern, | 251 helper_->SimulateAddProcessToPattern(pattern, |
209 helper_->mock_render_process_id()); | 252 helper_->mock_render_process_id()); |
210 | 253 |
211 // Start should succeed. | 254 // Start should succeed. |
212 ServiceWorkerStatusCode status; | 255 ServiceWorkerStatusCode status; |
213 base::RunLoop run_loop; | 256 base::RunLoop run_loop; |
214 std::unique_ptr<EmbeddedWorkerStartParams> params = | 257 std::unique_ptr<EmbeddedWorkerStartParams> params = |
215 CreateStartParams(service_worker_version_id, pattern, url); | 258 CreateStartParams(service_worker_version_id, pattern, url); |
216 worker->Start( | 259 worker->Start( |
217 std::move(params), CreateEventDispatcher(), | 260 std::move(params), CreateProviderClientInfoGetter(), |
261 CreateEventDispatcher(), | |
218 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); | 262 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
219 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); | 263 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); |
220 run_loop.Run(); | 264 run_loop.Run(); |
221 EXPECT_EQ(SERVICE_WORKER_OK, status); | 265 EXPECT_EQ(SERVICE_WORKER_OK, status); |
222 | 266 |
223 // The 'WorkerStarted' message should have been sent by | 267 // The 'WorkerStarted' message should have been sent by |
224 // EmbeddedWorkerTestHelper. | 268 // EmbeddedWorkerTestHelper. |
225 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); | 269 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); |
226 EXPECT_EQ(helper_->mock_render_process_id(), worker->process_id()); | 270 EXPECT_EQ(helper_->mock_render_process_id(), worker->process_id()); |
227 | 271 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
264 helper_->SimulateAddProcessToPattern(pattern, | 308 helper_->SimulateAddProcessToPattern(pattern, |
265 helper_->new_render_process_id()); | 309 helper_->new_render_process_id()); |
266 | 310 |
267 { | 311 { |
268 // Start once normally. | 312 // Start once normally. |
269 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 313 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
270 base::RunLoop run_loop; | 314 base::RunLoop run_loop; |
271 std::unique_ptr<EmbeddedWorkerStartParams> params = | 315 std::unique_ptr<EmbeddedWorkerStartParams> params = |
272 CreateStartParams(service_worker_version_id, pattern, url); | 316 CreateStartParams(service_worker_version_id, pattern, url); |
273 worker->Start( | 317 worker->Start( |
274 std::move(params), CreateEventDispatcher(), | 318 std::move(params), CreateProviderClientInfoGetter(), |
319 CreateEventDispatcher(), | |
275 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); | 320 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
276 run_loop.Run(); | 321 run_loop.Run(); |
277 EXPECT_EQ(SERVICE_WORKER_OK, status); | 322 EXPECT_EQ(SERVICE_WORKER_OK, status); |
278 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); | 323 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); |
279 // The worker should be using the default render process. | 324 // The worker should be using the default render process. |
280 EXPECT_EQ(helper_->mock_render_process_id(), worker->process_id()); | 325 EXPECT_EQ(helper_->mock_render_process_id(), worker->process_id()); |
281 | 326 |
282 EXPECT_TRUE(worker->Stop()); | 327 EXPECT_TRUE(worker->Stop()); |
283 base::RunLoop().RunUntilIdle(); | 328 base::RunLoop().RunUntilIdle(); |
284 } | 329 } |
285 | 330 |
286 // Fail twice. | 331 // Fail twice. |
287 context()->UpdateVersionFailureCount(service_worker_version_id, | 332 context()->UpdateVersionFailureCount(service_worker_version_id, |
288 SERVICE_WORKER_ERROR_FAILED); | 333 SERVICE_WORKER_ERROR_FAILED); |
289 context()->UpdateVersionFailureCount(service_worker_version_id, | 334 context()->UpdateVersionFailureCount(service_worker_version_id, |
290 SERVICE_WORKER_ERROR_FAILED); | 335 SERVICE_WORKER_ERROR_FAILED); |
291 | 336 |
292 { | 337 { |
293 // Start again. | 338 // Start again. |
294 ServiceWorkerStatusCode status; | 339 ServiceWorkerStatusCode status; |
295 base::RunLoop run_loop; | 340 base::RunLoop run_loop; |
296 std::unique_ptr<EmbeddedWorkerStartParams> params = | 341 std::unique_ptr<EmbeddedWorkerStartParams> params = |
297 CreateStartParams(service_worker_version_id, pattern, url); | 342 CreateStartParams(service_worker_version_id, pattern, url); |
298 worker->Start( | 343 worker->Start( |
299 std::move(params), CreateEventDispatcher(), | 344 std::move(params), CreateProviderClientInfoGetter(), |
345 CreateEventDispatcher(), | |
300 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); | 346 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
301 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); | 347 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status()); |
302 run_loop.Run(); | 348 run_loop.Run(); |
303 EXPECT_EQ(SERVICE_WORKER_OK, status); | 349 EXPECT_EQ(SERVICE_WORKER_OK, status); |
304 | 350 |
305 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); | 351 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); |
306 // The worker should be using the new render process. | 352 // The worker should be using the new render process. |
307 EXPECT_EQ(helper_->new_render_process_id(), worker->process_id()); | 353 EXPECT_EQ(helper_->new_render_process_id(), worker->process_id()); |
308 EXPECT_TRUE(worker->Stop()); | 354 EXPECT_TRUE(worker->Stop()); |
309 base::RunLoop().RunUntilIdle(); | 355 base::RunLoop().RunUntilIdle(); |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
370 int process_id = helper_->mock_render_process_id(); | 416 int process_id = helper_->mock_render_process_id(); |
371 | 417 |
372 helper_->SimulateAddProcessToPattern(pattern, process_id); | 418 helper_->SimulateAddProcessToPattern(pattern, process_id); |
373 { | 419 { |
374 // Start worker1. | 420 // Start worker1. |
375 ServiceWorkerStatusCode status; | 421 ServiceWorkerStatusCode status; |
376 base::RunLoop run_loop; | 422 base::RunLoop run_loop; |
377 std::unique_ptr<EmbeddedWorkerStartParams> params = | 423 std::unique_ptr<EmbeddedWorkerStartParams> params = |
378 CreateStartParams(version_id1, pattern, url); | 424 CreateStartParams(version_id1, pattern, url); |
379 worker1->Start( | 425 worker1->Start( |
380 std::move(params), CreateEventDispatcher(), | 426 std::move(params), CreateProviderClientInfoGetter(), |
427 CreateEventDispatcher(), | |
381 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); | 428 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
382 run_loop.Run(); | 429 run_loop.Run(); |
383 EXPECT_EQ(SERVICE_WORKER_OK, status); | 430 EXPECT_EQ(SERVICE_WORKER_OK, status); |
384 } | 431 } |
385 | 432 |
386 { | 433 { |
387 // Start worker2. | 434 // Start worker2. |
388 ServiceWorkerStatusCode status; | 435 ServiceWorkerStatusCode status; |
389 base::RunLoop run_loop; | 436 base::RunLoop run_loop; |
390 std::unique_ptr<EmbeddedWorkerStartParams> params = | 437 std::unique_ptr<EmbeddedWorkerStartParams> params = |
391 CreateStartParams(version_id2, pattern, url); | 438 CreateStartParams(version_id2, pattern, url); |
392 worker2->Start( | 439 worker2->Start( |
393 std::move(params), CreateEventDispatcher(), | 440 std::move(params), CreateProviderClientInfoGetter(), |
441 CreateEventDispatcher(), | |
394 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); | 442 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
395 run_loop.Run(); | 443 run_loop.Run(); |
396 EXPECT_EQ(SERVICE_WORKER_OK, status); | 444 EXPECT_EQ(SERVICE_WORKER_OK, status); |
397 } | 445 } |
398 | 446 |
399 // The two workers share the same process. | 447 // The two workers share the same process. |
400 EXPECT_EQ(worker1->process_id(), worker2->process_id()); | 448 EXPECT_EQ(worker1->process_id(), worker2->process_id()); |
401 | 449 |
402 // Destroy worker1. It removes itself from the registry. | 450 // Destroy worker1. It removes itself from the registry. |
403 int worker1_id = worker1->embedded_worker_id(); | 451 int worker1_id = worker1->embedded_worker_id(); |
(...skipping 17 matching lines...) Expand all Loading... | |
421 | 469 |
422 std::unique_ptr<EmbeddedWorkerInstance> worker = | 470 std::unique_ptr<EmbeddedWorkerInstance> worker = |
423 embedded_worker_registry()->CreateWorker(); | 471 embedded_worker_registry()->CreateWorker(); |
424 worker->AddListener(this); | 472 worker->AddListener(this); |
425 | 473 |
426 // Run the start worker sequence and detach during process allocation. | 474 // Run the start worker sequence and detach during process allocation. |
427 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 475 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
428 std::unique_ptr<EmbeddedWorkerStartParams> params = | 476 std::unique_ptr<EmbeddedWorkerStartParams> params = |
429 CreateStartParams(version_id, scope, url); | 477 CreateStartParams(version_id, scope, url); |
430 worker->Start( | 478 worker->Start( |
431 std::move(params), CreateEventDispatcher(), | 479 std::move(params), CreateProviderClientInfoGetter(), |
480 CreateEventDispatcher(), | |
432 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); | 481 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); |
433 worker->Detach(); | 482 worker->Detach(); |
434 base::RunLoop().RunUntilIdle(); | 483 base::RunLoop().RunUntilIdle(); |
435 | 484 |
436 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); | 485 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); |
437 EXPECT_EQ(ChildProcessHost::kInvalidUniqueID, worker->process_id()); | 486 EXPECT_EQ(ChildProcessHost::kInvalidUniqueID, worker->process_id()); |
438 | 487 |
439 // The start callback should not be aborted by detach (see a comment on the | 488 // The start callback should not be aborted by detach (see a comment on the |
440 // dtor of EmbeddedWorkerInstance::StartTask). | 489 // dtor of EmbeddedWorkerInstance::StartTask). |
441 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); | 490 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); |
(...skipping 12 matching lines...) Expand all Loading... | |
454 helper_.reset(new StalledInStartWorkerHelper()); | 503 helper_.reset(new StalledInStartWorkerHelper()); |
455 std::unique_ptr<EmbeddedWorkerInstance> worker = | 504 std::unique_ptr<EmbeddedWorkerInstance> worker = |
456 embedded_worker_registry()->CreateWorker(); | 505 embedded_worker_registry()->CreateWorker(); |
457 worker->AddListener(this); | 506 worker->AddListener(this); |
458 | 507 |
459 // Run the start worker sequence until a start worker message is sent. | 508 // Run the start worker sequence until a start worker message is sent. |
460 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 509 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
461 std::unique_ptr<EmbeddedWorkerStartParams> params = | 510 std::unique_ptr<EmbeddedWorkerStartParams> params = |
462 CreateStartParams(version_id, scope, url); | 511 CreateStartParams(version_id, scope, url); |
463 worker->Start( | 512 worker->Start( |
464 std::move(params), CreateEventDispatcher(), | 513 std::move(params), CreateProviderClientInfoGetter(), |
514 CreateEventDispatcher(), | |
465 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); | 515 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); |
466 base::RunLoop().RunUntilIdle(); | 516 base::RunLoop().RunUntilIdle(); |
467 | 517 |
468 ASSERT_EQ(2u, events_.size()); | 518 ASSERT_EQ(2u, events_.size()); |
469 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 519 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
470 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 520 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
471 events_.clear(); | 521 events_.clear(); |
472 | 522 |
473 worker->Detach(); | 523 worker->Detach(); |
474 base::RunLoop().RunUntilIdle(); | 524 base::RunLoop().RunUntilIdle(); |
(...skipping 19 matching lines...) Expand all Loading... | |
494 std::unique_ptr<EmbeddedWorkerInstance> worker = | 544 std::unique_ptr<EmbeddedWorkerInstance> worker = |
495 embedded_worker_registry()->CreateWorker(); | 545 embedded_worker_registry()->CreateWorker(); |
496 worker->AddListener(this); | 546 worker->AddListener(this); |
497 | 547 |
498 // Stop the start worker sequence before a process is allocated. | 548 // Stop the start worker sequence before a process is allocated. |
499 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 549 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
500 | 550 |
501 std::unique_ptr<EmbeddedWorkerStartParams> params = | 551 std::unique_ptr<EmbeddedWorkerStartParams> params = |
502 CreateStartParams(version_id, scope, url); | 552 CreateStartParams(version_id, scope, url); |
503 worker->Start( | 553 worker->Start( |
504 std::move(params), CreateEventDispatcher(), | 554 std::move(params), CreateProviderClientInfoGetter(), |
555 CreateEventDispatcher(), | |
505 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); | 556 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); |
506 worker->Stop(); | 557 worker->Stop(); |
507 base::RunLoop().RunUntilIdle(); | 558 base::RunLoop().RunUntilIdle(); |
508 | 559 |
509 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); | 560 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); |
510 EXPECT_EQ(ChildProcessHost::kInvalidUniqueID, worker->process_id()); | 561 EXPECT_EQ(ChildProcessHost::kInvalidUniqueID, worker->process_id()); |
511 | 562 |
512 // The start callback should not be aborted by stop (see a comment on the dtor | 563 // The start callback should not be aborted by stop (see a comment on the dtor |
513 // of EmbeddedWorkerInstance::StartTask). | 564 // of EmbeddedWorkerInstance::StartTask). |
514 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); | 565 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); |
515 | 566 |
516 // "PROCESS_ALLOCATED" event should not be recorded. | 567 // "PROCESS_ALLOCATED" event should not be recorded. |
517 ASSERT_EQ(1u, events_.size()); | 568 ASSERT_EQ(1u, events_.size()); |
518 EXPECT_EQ(DETACHED, events_[0].type); | 569 EXPECT_EQ(DETACHED, events_[0].type); |
519 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[0].status); | 570 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[0].status); |
520 events_.clear(); | 571 events_.clear(); |
521 | 572 |
522 // Restart the worker. | 573 // Restart the worker. |
523 status = SERVICE_WORKER_ERROR_MAX_VALUE; | 574 status = SERVICE_WORKER_ERROR_MAX_VALUE; |
524 std::unique_ptr<base::RunLoop> run_loop(new base::RunLoop); | 575 std::unique_ptr<base::RunLoop> run_loop(new base::RunLoop); |
525 params = CreateStartParams(version_id, scope, url); | 576 params = CreateStartParams(version_id, scope, url); |
526 worker->Start( | 577 worker->Start( |
527 std::move(params), CreateEventDispatcher(), | 578 std::move(params), CreateProviderClientInfoGetter(), |
579 CreateEventDispatcher(), | |
528 base::Bind(&SaveStatusAndCall, &status, run_loop->QuitClosure())); | 580 base::Bind(&SaveStatusAndCall, &status, run_loop->QuitClosure())); |
529 run_loop->Run(); | 581 run_loop->Run(); |
530 | 582 |
531 EXPECT_EQ(SERVICE_WORKER_OK, status); | 583 EXPECT_EQ(SERVICE_WORKER_OK, status); |
532 ASSERT_EQ(3u, events_.size()); | 584 ASSERT_EQ(3u, events_.size()); |
533 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 585 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
534 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 586 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
535 EXPECT_EQ(STARTED, events_[2].type); | 587 EXPECT_EQ(STARTED, events_[2].type); |
536 | 588 |
537 // Tear down the worker. | 589 // Tear down the worker. |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
569 embedded_worker_registry()->CreateWorker(); | 621 embedded_worker_registry()->CreateWorker(); |
570 worker->AddListener(this); | 622 worker->AddListener(this); |
571 | 623 |
572 // Run the start worker sequence until pause after download. | 624 // Run the start worker sequence until pause after download. |
573 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 625 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
574 | 626 |
575 std::unique_ptr<EmbeddedWorkerStartParams> params = | 627 std::unique_ptr<EmbeddedWorkerStartParams> params = |
576 CreateStartParams(version_id, scope, url); | 628 CreateStartParams(version_id, scope, url); |
577 params->pause_after_download = true; | 629 params->pause_after_download = true; |
578 worker->Start( | 630 worker->Start( |
579 std::move(params), CreateEventDispatcher(), | 631 std::move(params), CreateProviderClientInfoGetter(), |
632 CreateEventDispatcher(), | |
580 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); | 633 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); |
581 base::RunLoop().RunUntilIdle(); | 634 base::RunLoop().RunUntilIdle(); |
582 | 635 |
583 // Make the worker stopping and attempt to send a resume after download | 636 // Make the worker stopping and attempt to send a resume after download |
584 // message. | 637 // message. |
585 worker->Stop(); | 638 worker->Stop(); |
586 worker->ResumeAfterDownload(); | 639 worker->ResumeAfterDownload(); |
587 base::RunLoop().RunUntilIdle(); | 640 base::RunLoop().RunUntilIdle(); |
588 | 641 |
589 // The resume after download message should not have been sent. | 642 // The resume after download message should not have been sent. |
590 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); | 643 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); |
591 EXPECT_FALSE(was_resume_after_download_called); | 644 EXPECT_FALSE(was_resume_after_download_called); |
592 } | 645 } |
593 | 646 |
594 TEST_F(EmbeddedWorkerInstanceTest, StopAfterSendingStartWorkerMessage) { | 647 TEST_F(EmbeddedWorkerInstanceTest, StopAfterSendingStartWorkerMessage) { |
595 const int64_t version_id = 55L; | 648 const int64_t version_id = 55L; |
596 const GURL scope("http://example.com/"); | 649 const GURL scope("http://example.com/"); |
597 const GURL url("http://example.com/worker.js"); | 650 const GURL url("http://example.com/worker.js"); |
598 | 651 |
599 helper_.reset(new StalledInStartWorkerHelper); | 652 helper_.reset(new StalledInStartWorkerHelper); |
600 std::unique_ptr<EmbeddedWorkerInstance> worker = | 653 std::unique_ptr<EmbeddedWorkerInstance> worker = |
601 embedded_worker_registry()->CreateWorker(); | 654 embedded_worker_registry()->CreateWorker(); |
602 worker->AddListener(this); | 655 worker->AddListener(this); |
603 | 656 |
604 // Run the start worker sequence until a start worker message is sent. | 657 // Run the start worker sequence until a start worker message is sent. |
605 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 658 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
606 std::unique_ptr<EmbeddedWorkerStartParams> params = | 659 std::unique_ptr<EmbeddedWorkerStartParams> params = |
607 CreateStartParams(version_id, scope, url); | 660 CreateStartParams(version_id, scope, url); |
608 worker->Start( | 661 worker->Start( |
609 std::move(params), CreateEventDispatcher(), | 662 std::move(params), CreateProviderClientInfoGetter(), |
663 CreateEventDispatcher(), | |
610 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); | 664 base::Bind(&SaveStatusAndCall, &status, base::Bind(&base::DoNothing))); |
611 base::RunLoop().RunUntilIdle(); | 665 base::RunLoop().RunUntilIdle(); |
612 | 666 |
613 ASSERT_EQ(2u, events_.size()); | 667 ASSERT_EQ(2u, events_.size()); |
614 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 668 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
615 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 669 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
616 events_.clear(); | 670 events_.clear(); |
617 | 671 |
618 worker->Stop(); | 672 worker->Stop(); |
619 base::RunLoop().RunUntilIdle(); | 673 base::RunLoop().RunUntilIdle(); |
(...skipping 12 matching lines...) Expand all Loading... | |
632 events_.clear(); | 686 events_.clear(); |
633 | 687 |
634 // Restart the worker. | 688 // Restart the worker. |
635 static_cast<StalledInStartWorkerHelper*>(helper_.get()) | 689 static_cast<StalledInStartWorkerHelper*>(helper_.get()) |
636 ->set_force_stall_in_start(false); | 690 ->set_force_stall_in_start(false); |
637 status = SERVICE_WORKER_ERROR_MAX_VALUE; | 691 status = SERVICE_WORKER_ERROR_MAX_VALUE; |
638 std::unique_ptr<base::RunLoop> run_loop(new base::RunLoop); | 692 std::unique_ptr<base::RunLoop> run_loop(new base::RunLoop); |
639 | 693 |
640 params = CreateStartParams(version_id, scope, url); | 694 params = CreateStartParams(version_id, scope, url); |
641 worker->Start( | 695 worker->Start( |
642 std::move(params), CreateEventDispatcher(), | 696 std::move(params), CreateProviderClientInfoGetter(), |
697 CreateEventDispatcher(), | |
643 base::Bind(&SaveStatusAndCall, &status, run_loop->QuitClosure())); | 698 base::Bind(&SaveStatusAndCall, &status, run_loop->QuitClosure())); |
644 run_loop->Run(); | 699 run_loop->Run(); |
645 | 700 |
646 // The worker should be started. | 701 // The worker should be started. |
647 EXPECT_EQ(SERVICE_WORKER_OK, status); | 702 EXPECT_EQ(SERVICE_WORKER_OK, status); |
648 ASSERT_EQ(3u, events_.size()); | 703 ASSERT_EQ(3u, events_.size()); |
649 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 704 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
650 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 705 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
651 EXPECT_EQ(STARTED, events_[2].type); | 706 EXPECT_EQ(STARTED, events_[2].type); |
652 | 707 |
(...skipping 10 matching lines...) Expand all Loading... | |
663 helper_->SimulateAddProcessToPattern(pattern, | 718 helper_->SimulateAddProcessToPattern(pattern, |
664 helper_->mock_render_process_id()); | 719 helper_->mock_render_process_id()); |
665 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 720 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
666 worker->AddListener(this); | 721 worker->AddListener(this); |
667 | 722 |
668 // Start the worker. | 723 // Start the worker. |
669 base::RunLoop run_loop; | 724 base::RunLoop run_loop; |
670 std::unique_ptr<EmbeddedWorkerStartParams> params = | 725 std::unique_ptr<EmbeddedWorkerStartParams> params = |
671 CreateStartParams(version_id, pattern, url); | 726 CreateStartParams(version_id, pattern, url); |
672 worker->Start( | 727 worker->Start( |
673 std::move(params), CreateEventDispatcher(), | 728 std::move(params), CreateProviderClientInfoGetter(), |
729 CreateEventDispatcher(), | |
674 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); | 730 base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); |
675 run_loop.Run(); | 731 run_loop.Run(); |
676 | 732 |
677 // Detach. | 733 // Detach. |
678 int process_id = worker->process_id(); | 734 int process_id = worker->process_id(); |
679 worker->Detach(); | 735 worker->Detach(); |
680 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); | 736 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); |
681 | 737 |
682 // Send the registry a message from the detached worker. Nothing should | 738 // Send the registry a message from the detached worker. Nothing should |
683 // happen. | 739 // happen. |
(...skipping 13 matching lines...) Expand all Loading... | |
697 | 753 |
698 std::unique_ptr<EmbeddedWorkerInstance> worker = | 754 std::unique_ptr<EmbeddedWorkerInstance> worker = |
699 embedded_worker_registry()->CreateWorker(); | 755 embedded_worker_registry()->CreateWorker(); |
700 helper_->SimulateAddProcessToPattern(pattern, | 756 helper_->SimulateAddProcessToPattern(pattern, |
701 helper_->mock_render_process_id()); | 757 helper_->mock_render_process_id()); |
702 worker->AddListener(this); | 758 worker->AddListener(this); |
703 | 759 |
704 // Attempt to start the worker. | 760 // Attempt to start the worker. |
705 std::unique_ptr<EmbeddedWorkerStartParams> params = | 761 std::unique_ptr<EmbeddedWorkerStartParams> params = |
706 CreateStartParams(version_id, pattern, url); | 762 CreateStartParams(version_id, pattern, url); |
707 worker->Start(std::move(params), CreateEventDispatcher(), | 763 worker->Start(std::move(params), CreateProviderClientInfoGetter(), |
764 CreateEventDispatcher(), | |
708 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 765 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
709 base::RunLoop().RunUntilIdle(); | 766 base::RunLoop().RunUntilIdle(); |
710 | 767 |
711 // Worker should handle the failure of binding as detach. | 768 // Worker should handle the failure of binding as detach. |
712 ASSERT_EQ(2u, events_.size()); | 769 ASSERT_EQ(2u, events_.size()); |
713 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 770 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
714 EXPECT_EQ(DETACHED, events_[1].type); | 771 EXPECT_EQ(DETACHED, events_[1].type); |
715 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[1].status); | 772 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[1].status); |
716 } | 773 } |
717 | 774 |
718 class FailEmbeddedWorkerInstanceClientImpl | 775 class FailEmbeddedWorkerInstanceClientImpl |
719 : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient { | 776 : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient { |
720 public: | 777 public: |
721 explicit FailEmbeddedWorkerInstanceClientImpl( | 778 explicit FailEmbeddedWorkerInstanceClientImpl( |
722 base::WeakPtr<EmbeddedWorkerTestHelper> helper) | 779 base::WeakPtr<EmbeddedWorkerTestHelper> helper) |
723 : EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient(helper) {} | 780 : EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient(helper) {} |
724 | 781 |
725 private: | 782 private: |
726 void StartWorker( | 783 void StartWorker(const EmbeddedWorkerStartParams&, |
727 const EmbeddedWorkerStartParams& /* unused */, | 784 mojom::ServiceWorkerEventDispatcherRequest, |
728 mojom::ServiceWorkerEventDispatcherRequest /* unused */, | 785 mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo, |
729 mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo /* unused */) | 786 mojom::ServiceWorkerProviderInfoForStartWorkerPtr) override { |
730 override { | |
731 helper_->mock_instance_clients()->clear(); | 787 helper_->mock_instance_clients()->clear(); |
732 } | 788 } |
733 }; | 789 }; |
734 | 790 |
735 TEST_F(EmbeddedWorkerInstanceTest, RemoveRemoteInterface) { | 791 TEST_F(EmbeddedWorkerInstanceTest, RemoveRemoteInterface) { |
736 const int64_t version_id = 55L; | 792 const int64_t version_id = 55L; |
737 const GURL pattern("http://example.com/"); | 793 const GURL pattern("http://example.com/"); |
738 const GURL url("http://example.com/worker.js"); | 794 const GURL url("http://example.com/worker.js"); |
739 | 795 |
740 // Let StartWorker fail; binding is discarded in the middle of IPC | 796 // Let StartWorker fail; binding is discarded in the middle of IPC |
741 helper_->RegisterMockInstanceClient( | 797 helper_->RegisterMockInstanceClient( |
742 base::MakeUnique<FailEmbeddedWorkerInstanceClientImpl>( | 798 base::MakeUnique<FailEmbeddedWorkerInstanceClientImpl>( |
743 helper_->AsWeakPtr())); | 799 helper_->AsWeakPtr())); |
744 ASSERT_EQ(mock_instance_clients()->size(), 1UL); | 800 ASSERT_EQ(mock_instance_clients()->size(), 1UL); |
745 | 801 |
746 std::unique_ptr<EmbeddedWorkerInstance> worker = | 802 std::unique_ptr<EmbeddedWorkerInstance> worker = |
747 embedded_worker_registry()->CreateWorker(); | 803 embedded_worker_registry()->CreateWorker(); |
748 helper_->SimulateAddProcessToPattern(pattern, | 804 helper_->SimulateAddProcessToPattern(pattern, |
749 helper_->mock_render_process_id()); | 805 helper_->mock_render_process_id()); |
750 worker->AddListener(this); | 806 worker->AddListener(this); |
751 | 807 |
752 // Attempt to start the worker. | 808 // Attempt to start the worker. |
753 std::unique_ptr<EmbeddedWorkerStartParams> params = | 809 std::unique_ptr<EmbeddedWorkerStartParams> params = |
754 CreateStartParams(version_id, pattern, url); | 810 CreateStartParams(version_id, pattern, url); |
755 worker->Start(std::move(params), CreateEventDispatcher(), | 811 worker->Start(std::move(params), CreateProviderClientInfoGetter(), |
812 CreateEventDispatcher(), | |
756 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 813 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
757 base::RunLoop().RunUntilIdle(); | 814 base::RunLoop().RunUntilIdle(); |
758 | 815 |
759 // Worker should handle the sudden shutdown as detach. | 816 // Worker should handle the sudden shutdown as detach. |
760 ASSERT_EQ(3u, events_.size()); | 817 ASSERT_EQ(3u, events_.size()); |
761 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 818 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
762 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 819 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
763 EXPECT_EQ(DETACHED, events_[2].type); | 820 EXPECT_EQ(DETACHED, events_[2].type); |
764 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[2].status); | 821 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[2].status); |
765 } | 822 } |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
801 helper_->SimulateAddProcessToPattern(pattern, | 858 helper_->SimulateAddProcessToPattern(pattern, |
802 helper_->mock_render_process_id()); | 859 helper_->mock_render_process_id()); |
803 worker->AddListener(this); | 860 worker->AddListener(this); |
804 | 861 |
805 // Attempt to start the worker and immediate AddMessageToConsole should not | 862 // Attempt to start the worker and immediate AddMessageToConsole should not |
806 // cause a crash. | 863 // cause a crash. |
807 std::pair<blink::WebConsoleMessage::Level, std::string> test_message = | 864 std::pair<blink::WebConsoleMessage::Level, std::string> test_message = |
808 std::make_pair(blink::WebConsoleMessage::kLevelVerbose, ""); | 865 std::make_pair(blink::WebConsoleMessage::kLevelVerbose, ""); |
809 std::unique_ptr<EmbeddedWorkerStartParams> params = | 866 std::unique_ptr<EmbeddedWorkerStartParams> params = |
810 CreateStartParams(version_id, pattern, url); | 867 CreateStartParams(version_id, pattern, url); |
811 worker->Start(std::move(params), CreateEventDispatcher(), | 868 worker->Start(std::move(params), CreateProviderClientInfoGetter(), |
869 CreateEventDispatcher(), | |
812 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 870 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
813 worker->AddMessageToConsole(test_message.first, test_message.second); | 871 worker->AddMessageToConsole(test_message.first, test_message.second); |
814 base::RunLoop().RunUntilIdle(); | 872 base::RunLoop().RunUntilIdle(); |
815 | 873 |
816 // Messages sent before sending StartWorker message won't be dispatched. | 874 // Messages sent before sending StartWorker message won't be dispatched. |
817 ASSERT_EQ(0UL, instance_client_rawptr->message().size()); | 875 ASSERT_EQ(0UL, instance_client_rawptr->message().size()); |
818 ASSERT_EQ(3UL, events_.size()); | 876 ASSERT_EQ(3UL, events_.size()); |
819 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); | 877 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); |
820 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); | 878 EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type); |
821 EXPECT_EQ(STARTED, events_[2].type); | 879 EXPECT_EQ(STARTED, events_[2].type); |
822 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); | 880 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status()); |
823 | 881 |
824 worker->AddMessageToConsole(test_message.first, test_message.second); | 882 worker->AddMessageToConsole(test_message.first, test_message.second); |
825 base::RunLoop().RunUntilIdle(); | 883 base::RunLoop().RunUntilIdle(); |
826 | 884 |
827 // Messages sent after sending StartWorker message should be reached to | 885 // Messages sent after sending StartWorker message should be reached to |
828 // the renderer. | 886 // the renderer. |
829 ASSERT_EQ(1UL, instance_client_rawptr->message().size()); | 887 ASSERT_EQ(1UL, instance_client_rawptr->message().size()); |
830 EXPECT_EQ(test_message, instance_client_rawptr->message()[0]); | 888 EXPECT_EQ(test_message, instance_client_rawptr->message()[0]); |
831 | 889 |
832 // Ensure the worker is stopped. | 890 // Ensure the worker is stopped. |
833 worker->Stop(); | 891 worker->Stop(); |
834 base::RunLoop().RunUntilIdle(); | 892 base::RunLoop().RunUntilIdle(); |
835 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); | 893 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); |
836 } | 894 } |
837 | 895 |
838 } // namespace content | 896 } // namespace content |
OLD | NEW |