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