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 <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind_helpers.h" | 9 #include "base/bind_helpers.h" |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
(...skipping 198 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
209 // We can abort starting worker by destroying this task anytime during the | 209 // We can abort starting worker by destroying this task anytime during the |
210 // sequence. | 210 // sequence. |
211 class EmbeddedWorkerInstance::StartTask { | 211 class EmbeddedWorkerInstance::StartTask { |
212 public: | 212 public: |
213 enum class ProcessAllocationState { NOT_ALLOCATED, ALLOCATING, ALLOCATED }; | 213 enum class ProcessAllocationState { NOT_ALLOCATED, ALLOCATING, ALLOCATED }; |
214 | 214 |
215 StartTask(EmbeddedWorkerInstance* instance, const GURL& script_url) | 215 StartTask(EmbeddedWorkerInstance* instance, const GURL& script_url) |
216 : instance_(instance), | 216 : instance_(instance), |
217 state_(ProcessAllocationState::NOT_ALLOCATED), | 217 state_(ProcessAllocationState::NOT_ALLOCATED), |
218 is_installed_(false), | 218 is_installed_(false), |
219 start_situation_(ServiceWorkerMetrics::StartSituation::UNKNOWN), | 219 started_during_browser_startup_(false), |
220 weak_factory_(this) { | 220 weak_factory_(this) { |
221 TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker", "EmbeddedWorkerInstance::Start", | 221 TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker", "EmbeddedWorkerInstance::Start", |
222 this, "Script", script_url.spec()); | 222 this, "Script", script_url.spec()); |
223 } | 223 } |
224 | 224 |
225 ~StartTask() { | 225 ~StartTask() { |
226 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 226 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
227 TRACE_EVENT_ASYNC_END0("ServiceWorker", "EmbeddedWorkerInstance::Start", | 227 TRACE_EVENT_ASYNC_END0("ServiceWorker", "EmbeddedWorkerInstance::Start", |
228 this); | 228 this); |
229 | 229 |
(...skipping 26 matching lines...) Expand all Loading... |
256 } | 256 } |
257 | 257 |
258 void Start(std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params, | 258 void Start(std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params, |
259 const StatusCallback& callback) { | 259 const StatusCallback& callback) { |
260 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 260 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
261 state_ = ProcessAllocationState::ALLOCATING; | 261 state_ = ProcessAllocationState::ALLOCATING; |
262 start_callback_ = callback; | 262 start_callback_ = callback; |
263 is_installed_ = params->is_installed; | 263 is_installed_ = params->is_installed; |
264 | 264 |
265 if (!GetContentClient()->browser()->IsBrowserStartupComplete()) | 265 if (!GetContentClient()->browser()->IsBrowserStartupComplete()) |
266 start_situation_ = ServiceWorkerMetrics::StartSituation::DURING_STARTUP; | 266 started_during_browser_startup_ = true; |
267 | 267 |
268 GURL scope(params->scope); | 268 GURL scope(params->scope); |
269 GURL script_url(params->script_url); | 269 GURL script_url(params->script_url); |
270 | 270 |
271 bool can_use_existing_process = | 271 bool can_use_existing_process = |
272 instance_->context_->GetVersionFailureCount( | 272 instance_->context_->GetVersionFailureCount( |
273 params->service_worker_version_id) < kMaxSameProcessFailureCount; | 273 params->service_worker_version_id) < kMaxSameProcessFailureCount; |
274 instance_->context_->process_manager()->AllocateWorkerProcess( | 274 instance_->context_->process_manager()->AllocateWorkerProcess( |
275 instance_->embedded_worker_id_, scope, script_url, | 275 instance_->embedded_worker_id_, scope, script_url, |
276 can_use_existing_process, | 276 can_use_existing_process, |
277 base::Bind(&StartTask::OnProcessAllocated, weak_factory_.GetWeakPtr(), | 277 base::Bind(&StartTask::OnProcessAllocated, weak_factory_.GetWeakPtr(), |
278 base::Passed(¶ms))); | 278 base::Passed(¶ms))); |
279 } | 279 } |
280 | 280 |
281 static void RunStartCallback(StartTask* task, | 281 static void RunStartCallback(StartTask* task, |
282 ServiceWorkerStatusCode status) { | 282 ServiceWorkerStatusCode status) { |
283 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 283 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
284 StatusCallback callback = task->start_callback_; | 284 StatusCallback callback = task->start_callback_; |
285 task->start_callback_.Reset(); | 285 task->start_callback_.Reset(); |
286 callback.Run(status); | 286 callback.Run(status); |
287 // |task| may be destroyed. | 287 // |task| may be destroyed. |
288 } | 288 } |
289 | 289 |
290 bool is_installed() const { return is_installed_; } | 290 bool is_installed() const { return is_installed_; } |
291 ServiceWorkerMetrics::StartSituation start_situation() const { | |
292 return start_situation_; | |
293 } | |
294 | 291 |
295 private: | 292 private: |
296 void OnProcessAllocated( | 293 void OnProcessAllocated( |
297 std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params, | 294 std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params, |
298 ServiceWorkerStatusCode status, | 295 ServiceWorkerStatusCode status, |
299 int process_id, | 296 int process_id, |
300 bool is_new_process, | 297 bool is_new_process, |
301 const EmbeddedWorkerSettings& settings) { | 298 const EmbeddedWorkerSettings& settings) { |
302 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 299 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
303 | 300 |
304 if (status != SERVICE_WORKER_OK) { | 301 if (status != SERVICE_WORKER_OK) { |
305 TRACE_EVENT_ASYNC_STEP_PAST1( | 302 TRACE_EVENT_ASYNC_STEP_PAST1( |
306 "ServiceWorker", "EmbeddedWorkerInstance::Start", this, | 303 "ServiceWorker", "EmbeddedWorkerInstance::Start", this, |
307 "OnProcessAllocated", "Error", ServiceWorkerStatusToString(status)); | 304 "OnProcessAllocated", "Error", ServiceWorkerStatusToString(status)); |
308 DCHECK_EQ(ChildProcessHost::kInvalidUniqueID, process_id); | 305 DCHECK_EQ(ChildProcessHost::kInvalidUniqueID, process_id); |
309 StatusCallback callback = start_callback_; | 306 StatusCallback callback = start_callback_; |
310 start_callback_.Reset(); | 307 start_callback_.Reset(); |
311 instance_->OnStartFailed(callback, status); | 308 instance_->OnStartFailed(callback, status); |
312 // |this| may be destroyed. | 309 // |this| may be destroyed. |
313 return; | 310 return; |
314 } | 311 } |
315 | 312 |
316 TRACE_EVENT_ASYNC_STEP_PAST1( | 313 TRACE_EVENT_ASYNC_STEP_PAST1( |
317 "ServiceWorker", "EmbeddedWorkerInstance::Start", this, | 314 "ServiceWorker", "EmbeddedWorkerInstance::Start", this, |
318 "OnProcessAllocated", "Is New Process", is_new_process); | 315 "OnProcessAllocated", "Is New Process", is_new_process); |
319 if (is_installed_) | 316 if (is_installed_) |
320 ServiceWorkerMetrics::RecordProcessCreated(is_new_process); | 317 ServiceWorkerMetrics::RecordProcessCreated(is_new_process); |
321 | 318 |
322 if (start_situation_ == ServiceWorkerMetrics::StartSituation::UNKNOWN) { | 319 ServiceWorkerMetrics::StartSituation start_situation = |
323 if (is_new_process) | 320 ServiceWorkerMetrics::StartSituation::UNKNOWN; |
324 start_situation_ = ServiceWorkerMetrics::StartSituation::NEW_PROCESS; | 321 if (started_during_browser_startup_) |
325 else | 322 start_situation = ServiceWorkerMetrics::StartSituation::DURING_STARTUP; |
326 start_situation_ = | 323 else if (is_new_process) |
327 ServiceWorkerMetrics::StartSituation::EXISTING_PROCESS; | 324 start_situation = ServiceWorkerMetrics::StartSituation::NEW_PROCESS; |
328 } | 325 else |
| 326 start_situation = ServiceWorkerMetrics::StartSituation::EXISTING_PROCESS; |
329 | 327 |
330 // Notify the instance that a process is allocated. | 328 // Notify the instance that a process is allocated. |
331 state_ = ProcessAllocationState::ALLOCATED; | 329 state_ = ProcessAllocationState::ALLOCATED; |
332 instance_->OnProcessAllocated(base::WrapUnique(new WorkerProcessHandle( | 330 instance_->OnProcessAllocated( |
333 instance_->context_, instance_->embedded_worker_id(), process_id, | 331 base::WrapUnique(new WorkerProcessHandle( |
334 is_new_process))); | 332 instance_->context_, instance_->embedded_worker_id(), process_id, |
| 333 is_new_process)), |
| 334 start_situation); |
335 | 335 |
336 // TODO(bengr): Support changes to this setting while the worker | 336 // TODO(bengr): Support changes to this setting while the worker |
337 // is running. | 337 // is running. |
338 params->settings.data_saver_enabled = settings.data_saver_enabled; | 338 params->settings.data_saver_enabled = settings.data_saver_enabled; |
339 | 339 |
340 // Register the instance to DevToolsManager on UI thread. | 340 // Register the instance to DevToolsManager on UI thread. |
341 const int64_t service_worker_version_id = params->service_worker_version_id; | 341 const int64_t service_worker_version_id = params->service_worker_version_id; |
342 const GURL& scope = params->scope; | 342 const GURL& scope = params->scope; |
343 GURL script_url(params->script_url); | 343 GURL script_url(params->script_url); |
344 BrowserThread::PostTask( | 344 BrowserThread::PostTask( |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
392 } | 392 } |
393 | 393 |
394 // |instance_| must outlive |this|. | 394 // |instance_| must outlive |this|. |
395 EmbeddedWorkerInstance* instance_; | 395 EmbeddedWorkerInstance* instance_; |
396 | 396 |
397 StatusCallback start_callback_; | 397 StatusCallback start_callback_; |
398 ProcessAllocationState state_; | 398 ProcessAllocationState state_; |
399 | 399 |
400 // Used for UMA. | 400 // Used for UMA. |
401 bool is_installed_; | 401 bool is_installed_; |
402 ServiceWorkerMetrics::StartSituation start_situation_; | 402 bool started_during_browser_startup_; |
403 | 403 |
404 base::WeakPtrFactory<StartTask> weak_factory_; | 404 base::WeakPtrFactory<StartTask> weak_factory_; |
405 | 405 |
406 DISALLOW_COPY_AND_ASSIGN(StartTask); | 406 DISALLOW_COPY_AND_ASSIGN(StartTask); |
407 }; | 407 }; |
408 | 408 |
409 bool EmbeddedWorkerInstance::Listener::OnMessageReceived( | 409 bool EmbeddedWorkerInstance::Listener::OnMessageReceived( |
410 const IPC::Message& message) { | 410 const IPC::Message& message) { |
411 return false; | 411 return false; |
412 } | 412 } |
413 | 413 |
414 EmbeddedWorkerInstance::~EmbeddedWorkerInstance() { | 414 EmbeddedWorkerInstance::~EmbeddedWorkerInstance() { |
415 DCHECK(status_ == STOPPING || status_ == STOPPED) << status_; | 415 DCHECK(status_ == Status::STOPPING || status_ == Status::STOPPED) |
| 416 << static_cast<int>(status_); |
416 devtools_proxy_.reset(); | 417 devtools_proxy_.reset(); |
417 if (registry_->GetWorker(embedded_worker_id_)) | 418 if (registry_->GetWorker(embedded_worker_id_)) |
418 registry_->RemoveWorker(process_id(), embedded_worker_id_); | 419 registry_->RemoveWorker(process_id(), embedded_worker_id_); |
419 process_handle_.reset(); | 420 process_handle_.reset(); |
420 } | 421 } |
421 | 422 |
422 void EmbeddedWorkerInstance::Start( | 423 void EmbeddedWorkerInstance::Start( |
423 std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params, | 424 std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params, |
424 const StatusCallback& callback) { | 425 const StatusCallback& callback) { |
425 if (!context_) { | 426 if (!context_) { |
426 callback.Run(SERVICE_WORKER_ERROR_ABORT); | 427 callback.Run(SERVICE_WORKER_ERROR_ABORT); |
427 // |this| may be destroyed by the callback. | 428 // |this| may be destroyed by the callback. |
428 return; | 429 return; |
429 } | 430 } |
430 DCHECK(status_ == STOPPED); | 431 DCHECK(status_ == Status::STOPPED); |
431 | 432 |
432 DCHECK(!params->pause_after_download || !params->is_installed); | 433 DCHECK(!params->pause_after_download || !params->is_installed); |
433 DCHECK_NE(kInvalidServiceWorkerVersionId, params->service_worker_version_id); | 434 DCHECK_NE(kInvalidServiceWorkerVersionId, params->service_worker_version_id); |
434 step_time_ = base::TimeTicks::Now(); | 435 step_time_ = base::TimeTicks::Now(); |
435 status_ = STARTING; | 436 status_ = Status::STARTING; |
436 starting_phase_ = ALLOCATING_PROCESS; | 437 starting_phase_ = ALLOCATING_PROCESS; |
437 network_accessed_for_script_ = false; | 438 network_accessed_for_script_ = false; |
438 service_registry_.reset(new ServiceRegistryImpl()); | 439 service_registry_.reset(new ServiceRegistryImpl()); |
439 FOR_EACH_OBSERVER(Listener, listener_list_, OnStarting()); | 440 FOR_EACH_OBSERVER(Listener, listener_list_, OnStarting()); |
440 | 441 |
441 params->embedded_worker_id = embedded_worker_id_; | 442 params->embedded_worker_id = embedded_worker_id_; |
442 params->worker_devtools_agent_route_id = MSG_ROUTING_NONE; | 443 params->worker_devtools_agent_route_id = MSG_ROUTING_NONE; |
443 params->wait_for_debugger = false; | 444 params->wait_for_debugger = false; |
444 params->settings.v8_cache_options = GetV8CacheOptions(); | 445 params->settings.v8_cache_options = GetV8CacheOptions(); |
445 | 446 |
446 inflight_start_task_.reset(new StartTask(this, params->script_url)); | 447 inflight_start_task_.reset(new StartTask(this, params->script_url)); |
447 inflight_start_task_->Start(std::move(params), callback); | 448 inflight_start_task_->Start(std::move(params), callback); |
448 } | 449 } |
449 | 450 |
450 ServiceWorkerStatusCode EmbeddedWorkerInstance::Stop() { | 451 ServiceWorkerStatusCode EmbeddedWorkerInstance::Stop() { |
451 DCHECK(status_ == STARTING || status_ == RUNNING) << status_; | 452 DCHECK(status_ == Status::STARTING || status_ == Status::RUNNING) |
| 453 << static_cast<int>(status_); |
452 | 454 |
453 // Abort an inflight start task. | 455 // Abort an inflight start task. |
454 inflight_start_task_.reset(); | 456 inflight_start_task_.reset(); |
455 | 457 |
456 ServiceWorkerStatusCode status = | 458 ServiceWorkerStatusCode status = |
457 registry_->StopWorker(process_id(), embedded_worker_id_); | 459 registry_->StopWorker(process_id(), embedded_worker_id_); |
458 UMA_HISTOGRAM_ENUMERATION("ServiceWorker.SendStopWorker.Status", status, | 460 UMA_HISTOGRAM_ENUMERATION("ServiceWorker.SendStopWorker.Status", status, |
459 SERVICE_WORKER_ERROR_MAX_VALUE); | 461 SERVICE_WORKER_ERROR_MAX_VALUE); |
460 // StopWorker could fail if we were starting up and don't have a process yet, | 462 // StopWorker could fail if we were starting up and don't have a process yet, |
461 // or we can no longer communicate with the process. So just detach. | 463 // or we can no longer communicate with the process. So just detach. |
462 if (status != SERVICE_WORKER_OK) { | 464 if (status != SERVICE_WORKER_OK) { |
463 OnDetached(); | 465 OnDetached(); |
464 return status; | 466 return status; |
465 } | 467 } |
466 | 468 |
467 status_ = STOPPING; | 469 status_ = Status::STOPPING; |
468 FOR_EACH_OBSERVER(Listener, listener_list_, OnStopping()); | 470 FOR_EACH_OBSERVER(Listener, listener_list_, OnStopping()); |
469 return status; | 471 return status; |
470 } | 472 } |
471 | 473 |
472 void EmbeddedWorkerInstance::StopIfIdle() { | 474 void EmbeddedWorkerInstance::StopIfIdle() { |
473 if (devtools_attached_) { | 475 if (devtools_attached_) { |
474 if (devtools_proxy_) | 476 if (devtools_proxy_) |
475 devtools_proxy_->NotifyWorkerStopIgnored(); | 477 devtools_proxy_->NotifyWorkerStopIgnored(); |
476 return; | 478 return; |
477 } | 479 } |
478 Stop(); | 480 Stop(); |
479 } | 481 } |
480 | 482 |
481 ServiceWorkerStatusCode EmbeddedWorkerInstance::SendMessage( | 483 ServiceWorkerStatusCode EmbeddedWorkerInstance::SendMessage( |
482 const IPC::Message& message) { | 484 const IPC::Message& message) { |
483 DCHECK_NE(kInvalidEmbeddedWorkerThreadId, thread_id_); | 485 DCHECK_NE(kInvalidEmbeddedWorkerThreadId, thread_id_); |
484 if (status_ != RUNNING && status_ != STARTING) | 486 if (status_ != Status::RUNNING && status_ != Status::STARTING) |
485 return SERVICE_WORKER_ERROR_IPC_FAILED; | 487 return SERVICE_WORKER_ERROR_IPC_FAILED; |
486 return registry_->Send(process_id(), | 488 return registry_->Send(process_id(), |
487 new EmbeddedWorkerContextMsg_MessageToWorker( | 489 new EmbeddedWorkerContextMsg_MessageToWorker( |
488 thread_id_, embedded_worker_id_, message)); | 490 thread_id_, embedded_worker_id_, message)); |
489 } | 491 } |
490 | 492 |
491 void EmbeddedWorkerInstance::ResumeAfterDownload() { | 493 void EmbeddedWorkerInstance::ResumeAfterDownload() { |
492 if (process_id() == ChildProcessHost::kInvalidUniqueID || status_ != STARTING) | 494 if (process_id() == ChildProcessHost::kInvalidUniqueID || |
| 495 status_ != Status::STARTING) { |
493 return; | 496 return; |
| 497 } |
494 registry_->Send(process_id(), new EmbeddedWorkerMsg_ResumeAfterDownload( | 498 registry_->Send(process_id(), new EmbeddedWorkerMsg_ResumeAfterDownload( |
495 embedded_worker_id_)); | 499 embedded_worker_id_)); |
496 } | 500 } |
497 | 501 |
498 ServiceRegistry* EmbeddedWorkerInstance::GetServiceRegistry() { | 502 ServiceRegistry* EmbeddedWorkerInstance::GetServiceRegistry() { |
499 DCHECK(status_ == STARTING || status_ == RUNNING) << status_; | 503 DCHECK(status_ == Status::STARTING || status_ == Status::RUNNING) |
| 504 << static_cast<int>(status_); |
500 return service_registry_.get(); | 505 return service_registry_.get(); |
501 } | 506 } |
502 | 507 |
503 EmbeddedWorkerInstance::EmbeddedWorkerInstance( | 508 EmbeddedWorkerInstance::EmbeddedWorkerInstance( |
504 base::WeakPtr<ServiceWorkerContextCore> context, | 509 base::WeakPtr<ServiceWorkerContextCore> context, |
505 int embedded_worker_id) | 510 int embedded_worker_id) |
506 : context_(context), | 511 : context_(context), |
507 registry_(context->embedded_worker_registry()), | 512 registry_(context->embedded_worker_registry()), |
508 embedded_worker_id_(embedded_worker_id), | 513 embedded_worker_id_(embedded_worker_id), |
509 status_(STOPPED), | 514 status_(Status::STOPPED), |
510 starting_phase_(NOT_STARTING), | 515 starting_phase_(NOT_STARTING), |
511 thread_id_(kInvalidEmbeddedWorkerThreadId), | 516 thread_id_(kInvalidEmbeddedWorkerThreadId), |
512 devtools_attached_(false), | 517 devtools_attached_(false), |
513 network_accessed_for_script_(false), | 518 network_accessed_for_script_(false), |
514 weak_factory_(this) {} | 519 weak_factory_(this) {} |
515 | 520 |
516 void EmbeddedWorkerInstance::OnProcessAllocated( | 521 void EmbeddedWorkerInstance::OnProcessAllocated( |
517 std::unique_ptr<WorkerProcessHandle> handle) { | 522 std::unique_ptr<WorkerProcessHandle> handle, |
518 DCHECK_EQ(STARTING, status_); | 523 ServiceWorkerMetrics::StartSituation start_situation) { |
| 524 DCHECK_EQ(Status::STARTING, status_); |
519 DCHECK(!process_handle_); | 525 DCHECK(!process_handle_); |
520 | 526 |
521 process_handle_ = std::move(handle); | 527 process_handle_ = std::move(handle); |
522 starting_phase_ = REGISTERING_TO_DEVTOOLS; | 528 starting_phase_ = REGISTERING_TO_DEVTOOLS; |
| 529 start_situation_ = start_situation; |
523 FOR_EACH_OBSERVER(Listener, listener_list_, OnProcessAllocated()); | 530 FOR_EACH_OBSERVER(Listener, listener_list_, OnProcessAllocated()); |
524 } | 531 } |
525 | 532 |
526 void EmbeddedWorkerInstance::OnRegisteredToDevToolsManager( | 533 void EmbeddedWorkerInstance::OnRegisteredToDevToolsManager( |
527 bool is_new_process, | 534 bool is_new_process, |
528 int worker_devtools_agent_route_id, | 535 int worker_devtools_agent_route_id, |
529 bool wait_for_debugger) { | 536 bool wait_for_debugger) { |
530 if (worker_devtools_agent_route_id != MSG_ROUTING_NONE) { | 537 if (worker_devtools_agent_route_id != MSG_ROUTING_NONE) { |
531 DCHECK(!devtools_proxy_); | 538 DCHECK(!devtools_proxy_); |
532 devtools_proxy_.reset( | 539 devtools_proxy_.reset( |
533 new DevToolsProxy(process_id(), worker_devtools_agent_route_id)); | 540 new DevToolsProxy(process_id(), worker_devtools_agent_route_id)); |
534 } | 541 } |
535 if (wait_for_debugger) { | 542 if (wait_for_debugger) { |
536 // We don't measure the start time when wait_for_debugger flag is set. So | 543 // We don't measure the start time when wait_for_debugger flag is set. So |
537 // we set the NULL time here. | 544 // we set the NULL time here. |
538 step_time_ = base::TimeTicks(); | 545 step_time_ = base::TimeTicks(); |
539 } | 546 } |
540 } | 547 } |
541 | 548 |
542 void EmbeddedWorkerInstance::OnStartWorkerMessageSent() { | 549 void EmbeddedWorkerInstance::OnStartWorkerMessageSent() { |
543 if (!step_time_.is_null()) { | 550 if (!step_time_.is_null()) { |
544 base::TimeDelta duration = UpdateStepTime(); | 551 base::TimeDelta duration = UpdateStepTime(); |
545 if (inflight_start_task_->is_installed()) { | 552 if (inflight_start_task_->is_installed()) { |
546 ServiceWorkerMetrics::RecordTimeToSendStartWorker( | 553 ServiceWorkerMetrics::RecordTimeToSendStartWorker(duration, |
547 duration, inflight_start_task_->start_situation()); | 554 start_situation_); |
548 } | 555 } |
549 } | 556 } |
550 | 557 |
551 starting_phase_ = SENT_START_WORKER; | 558 starting_phase_ = SENT_START_WORKER; |
552 FOR_EACH_OBSERVER(Listener, listener_list_, OnStartWorkerMessageSent()); | 559 FOR_EACH_OBSERVER(Listener, listener_list_, OnStartWorkerMessageSent()); |
553 } | 560 } |
554 | 561 |
555 void EmbeddedWorkerInstance::OnReadyForInspection() { | 562 void EmbeddedWorkerInstance::OnReadyForInspection() { |
556 if (devtools_proxy_) | 563 if (devtools_proxy_) |
557 devtools_proxy_->NotifyWorkerReadyForInspection(); | 564 devtools_proxy_->NotifyWorkerReadyForInspection(); |
(...skipping 21 matching lines...) Expand all Loading... |
579 } else { | 586 } else { |
580 source = LoadSource::HTTP_CACHE; | 587 source = LoadSource::HTTP_CACHE; |
581 } | 588 } |
582 TRACE_EVENT_ASYNC_STEP_PAST1( | 589 TRACE_EVENT_ASYNC_STEP_PAST1( |
583 "ServiceWorker", "EmbeddedWorkerInstance::Start", | 590 "ServiceWorker", "EmbeddedWorkerInstance::Start", |
584 inflight_start_task_.get(), "OnScriptLoaded", "Source", | 591 inflight_start_task_.get(), "OnScriptLoaded", "Source", |
585 ServiceWorkerMetrics::LoadSourceToString(source)); | 592 ServiceWorkerMetrics::LoadSourceToString(source)); |
586 | 593 |
587 if (!step_time_.is_null()) { | 594 if (!step_time_.is_null()) { |
588 base::TimeDelta duration = UpdateStepTime(); | 595 base::TimeDelta duration = UpdateStepTime(); |
589 ServiceWorkerMetrics::RecordTimeToLoad( | 596 ServiceWorkerMetrics::RecordTimeToLoad(duration, source, start_situation_); |
590 duration, source, inflight_start_task_->start_situation()); | |
591 } | 597 } |
592 | 598 |
593 starting_phase_ = SCRIPT_LOADED; | 599 starting_phase_ = SCRIPT_LOADED; |
594 FOR_EACH_OBSERVER(Listener, listener_list_, OnScriptLoaded()); | 600 FOR_EACH_OBSERVER(Listener, listener_list_, OnScriptLoaded()); |
595 // |this| may be destroyed by the callback. | 601 // |this| may be destroyed by the callback. |
596 } | 602 } |
597 | 603 |
598 void EmbeddedWorkerInstance::OnURLJobCreatedForMainScript() { | 604 void EmbeddedWorkerInstance::OnURLJobCreatedForMainScript() { |
599 if (!inflight_start_task_) | 605 if (!inflight_start_task_) |
600 return; | 606 return; |
601 TRACE_EVENT_ASYNC_STEP_PAST0("ServiceWorker", "EmbeddedWorkerInstance::Start", | 607 TRACE_EVENT_ASYNC_STEP_PAST0("ServiceWorker", "EmbeddedWorkerInstance::Start", |
602 inflight_start_task_.get(), "OnURLJobCreated"); | 608 inflight_start_task_.get(), "OnURLJobCreated"); |
603 if (!step_time_.is_null()) { | 609 if (!step_time_.is_null()) { |
604 base::TimeDelta duration = UpdateStepTime(); | 610 base::TimeDelta duration = UpdateStepTime(); |
605 if (inflight_start_task_->is_installed()) | 611 if (inflight_start_task_->is_installed()) |
606 ServiceWorkerMetrics::RecordTimeToURLJob( | 612 ServiceWorkerMetrics::RecordTimeToURLJob(duration, start_situation_); |
607 duration, inflight_start_task_->start_situation()); | |
608 } | 613 } |
609 } | 614 } |
610 | 615 |
611 void EmbeddedWorkerInstance::OnWorkerVersionInstalled() { | 616 void EmbeddedWorkerInstance::OnWorkerVersionInstalled() { |
612 if (devtools_proxy_) | 617 if (devtools_proxy_) |
613 devtools_proxy_->NotifyWorkerVersionInstalled(); | 618 devtools_proxy_->NotifyWorkerVersionInstalled(); |
614 } | 619 } |
615 | 620 |
616 void EmbeddedWorkerInstance::OnWorkerVersionDoomed() { | 621 void EmbeddedWorkerInstance::OnWorkerVersionDoomed() { |
617 if (devtools_proxy_) | 622 if (devtools_proxy_) |
618 devtools_proxy_->NotifyWorkerVersionDoomed(); | 623 devtools_proxy_->NotifyWorkerVersionDoomed(); |
619 } | 624 } |
620 | 625 |
621 void EmbeddedWorkerInstance::OnThreadStarted(int thread_id) { | 626 void EmbeddedWorkerInstance::OnThreadStarted(int thread_id) { |
622 if (!inflight_start_task_) | 627 if (!inflight_start_task_) |
623 return; | 628 return; |
624 TRACE_EVENT_ASYNC_STEP_PAST0("ServiceWorker", "EmbeddedWorkerInstance::Start", | 629 TRACE_EVENT_ASYNC_STEP_PAST0("ServiceWorker", "EmbeddedWorkerInstance::Start", |
625 inflight_start_task_.get(), "OnThreadStarted"); | 630 inflight_start_task_.get(), "OnThreadStarted"); |
626 | 631 |
627 starting_phase_ = THREAD_STARTED; | 632 starting_phase_ = THREAD_STARTED; |
628 if (!step_time_.is_null()) { | 633 if (!step_time_.is_null()) { |
629 base::TimeDelta duration = UpdateStepTime(); | 634 base::TimeDelta duration = UpdateStepTime(); |
630 if (inflight_start_task_->is_installed()) | 635 if (inflight_start_task_->is_installed()) |
631 ServiceWorkerMetrics::RecordTimeToStartThread( | 636 ServiceWorkerMetrics::RecordTimeToStartThread(duration, start_situation_); |
632 duration, inflight_start_task_->start_situation()); | |
633 } | 637 } |
634 | 638 |
635 thread_id_ = thread_id; | 639 thread_id_ = thread_id; |
636 FOR_EACH_OBSERVER(Listener, listener_list_, OnThreadStarted()); | 640 FOR_EACH_OBSERVER(Listener, listener_list_, OnThreadStarted()); |
637 | 641 |
638 shell::mojom::InterfaceProviderPtr exposed_services; | 642 shell::mojom::InterfaceProviderPtr exposed_services; |
639 service_registry_->Bind(GetProxy(&exposed_services)); | 643 service_registry_->Bind(GetProxy(&exposed_services)); |
640 shell::mojom::InterfaceProviderPtr services; | 644 shell::mojom::InterfaceProviderPtr services; |
641 shell::mojom::InterfaceProviderRequest services_request = GetProxy(&services); | 645 shell::mojom::InterfaceProviderRequest services_request = GetProxy(&services); |
642 BrowserThread::PostTask( | 646 BrowserThread::PostTask( |
643 BrowserThread::UI, FROM_HERE, | 647 BrowserThread::UI, FROM_HERE, |
644 base::Bind(SetupMojoOnUIThread, process_id(), thread_id_, | 648 base::Bind(SetupMojoOnUIThread, process_id(), thread_id_, |
645 base::Passed(&services_request), | 649 base::Passed(&services_request), |
646 base::Passed(exposed_services.PassInterface()))); | 650 base::Passed(exposed_services.PassInterface()))); |
647 service_registry_->BindRemoteServiceProvider(std::move(services)); | 651 service_registry_->BindRemoteServiceProvider(std::move(services)); |
648 } | 652 } |
649 | 653 |
650 void EmbeddedWorkerInstance::OnScriptLoadFailed() { | 654 void EmbeddedWorkerInstance::OnScriptLoadFailed() { |
651 if (!inflight_start_task_) | 655 if (!inflight_start_task_) |
652 return; | 656 return; |
653 TRACE_EVENT_ASYNC_STEP_PAST0("ServiceWorker", "EmbeddedWorkerInstance::Start", | 657 TRACE_EVENT_ASYNC_STEP_PAST0("ServiceWorker", "EmbeddedWorkerInstance::Start", |
654 inflight_start_task_.get(), | 658 inflight_start_task_.get(), |
655 "OnScriptLoadFailed"); | 659 "OnScriptLoadFailed"); |
656 FOR_EACH_OBSERVER(Listener, listener_list_, OnScriptLoadFailed()); | 660 FOR_EACH_OBSERVER(Listener, listener_list_, OnScriptLoadFailed()); |
657 } | 661 } |
658 | 662 |
659 void EmbeddedWorkerInstance::OnScriptEvaluated(bool success) { | 663 void EmbeddedWorkerInstance::OnScriptEvaluated(bool success) { |
660 if (!inflight_start_task_) | 664 if (!inflight_start_task_) |
661 return; | 665 return; |
662 DCHECK_EQ(STARTING, status_); | 666 DCHECK_EQ(Status::STARTING, status_); |
663 | 667 |
664 TRACE_EVENT_ASYNC_STEP_PAST1("ServiceWorker", "EmbeddedWorkerInstance::Start", | 668 TRACE_EVENT_ASYNC_STEP_PAST1("ServiceWorker", "EmbeddedWorkerInstance::Start", |
665 inflight_start_task_.get(), "OnScriptEvaluated", | 669 inflight_start_task_.get(), "OnScriptEvaluated", |
666 "Success", success); | 670 "Success", success); |
667 starting_phase_ = SCRIPT_EVALUATED; | 671 starting_phase_ = SCRIPT_EVALUATED; |
668 if (!step_time_.is_null()) { | 672 if (!step_time_.is_null()) { |
669 base::TimeDelta duration = UpdateStepTime(); | 673 base::TimeDelta duration = UpdateStepTime(); |
670 if (success && inflight_start_task_->is_installed()) | 674 if (success && inflight_start_task_->is_installed()) |
671 ServiceWorkerMetrics::RecordTimeToEvaluateScript( | 675 ServiceWorkerMetrics::RecordTimeToEvaluateScript(duration, |
672 duration, inflight_start_task_->start_situation()); | 676 start_situation_); |
673 } | 677 } |
674 | 678 |
675 base::WeakPtr<EmbeddedWorkerInstance> weak_this = weak_factory_.GetWeakPtr(); | 679 base::WeakPtr<EmbeddedWorkerInstance> weak_this = weak_factory_.GetWeakPtr(); |
676 StartTask::RunStartCallback( | 680 StartTask::RunStartCallback( |
677 inflight_start_task_.get(), | 681 inflight_start_task_.get(), |
678 success ? SERVICE_WORKER_OK | 682 success ? SERVICE_WORKER_OK |
679 : SERVICE_WORKER_ERROR_SCRIPT_EVALUATE_FAILED); | 683 : SERVICE_WORKER_ERROR_SCRIPT_EVALUATE_FAILED); |
680 // |this| may be destroyed by the callback. | 684 // |this| may be destroyed by the callback. |
681 } | 685 } |
682 | 686 |
683 void EmbeddedWorkerInstance::OnStarted() { | 687 void EmbeddedWorkerInstance::OnStarted() { |
684 // Stop is requested before OnStarted is sent back from the worker. | 688 // Stop is requested before OnStarted is sent back from the worker. |
685 if (status_ == STOPPING) | 689 if (status_ == Status::STOPPING) |
686 return; | 690 return; |
687 DCHECK(status_ == STARTING); | 691 DCHECK(status_ == Status::STARTING); |
688 status_ = RUNNING; | 692 status_ = Status::RUNNING; |
689 inflight_start_task_.reset(); | 693 inflight_start_task_.reset(); |
690 FOR_EACH_OBSERVER(Listener, listener_list_, OnStarted()); | 694 FOR_EACH_OBSERVER(Listener, listener_list_, OnStarted()); |
691 } | 695 } |
692 | 696 |
693 void EmbeddedWorkerInstance::OnStopped() { | 697 void EmbeddedWorkerInstance::OnStopped() { |
694 Status old_status = status_; | 698 Status old_status = status_; |
695 ReleaseProcess(); | 699 ReleaseProcess(); |
696 FOR_EACH_OBSERVER(Listener, listener_list_, OnStopped(old_status)); | 700 FOR_EACH_OBSERVER(Listener, listener_list_, OnStopped(old_status)); |
697 } | 701 } |
698 | 702 |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
778 starting_phase_ = SCRIPT_DOWNLOADING; | 782 starting_phase_ = SCRIPT_DOWNLOADING; |
779 network_accessed_for_script_ = true; | 783 network_accessed_for_script_ = true; |
780 } | 784 } |
781 | 785 |
782 void EmbeddedWorkerInstance::ReleaseProcess() { | 786 void EmbeddedWorkerInstance::ReleaseProcess() { |
783 // Abort an inflight start task. | 787 // Abort an inflight start task. |
784 inflight_start_task_.reset(); | 788 inflight_start_task_.reset(); |
785 | 789 |
786 devtools_proxy_.reset(); | 790 devtools_proxy_.reset(); |
787 process_handle_.reset(); | 791 process_handle_.reset(); |
788 status_ = STOPPED; | 792 status_ = Status::STOPPED; |
789 thread_id_ = kInvalidEmbeddedWorkerThreadId; | 793 thread_id_ = kInvalidEmbeddedWorkerThreadId; |
790 service_registry_.reset(); | 794 service_registry_.reset(); |
791 } | 795 } |
792 | 796 |
793 void EmbeddedWorkerInstance::OnStartFailed(const StatusCallback& callback, | 797 void EmbeddedWorkerInstance::OnStartFailed(const StatusCallback& callback, |
794 ServiceWorkerStatusCode status) { | 798 ServiceWorkerStatusCode status) { |
795 Status old_status = status_; | 799 Status old_status = status_; |
796 ReleaseProcess(); | 800 ReleaseProcess(); |
797 base::WeakPtr<EmbeddedWorkerInstance> weak_this = weak_factory_.GetWeakPtr(); | 801 base::WeakPtr<EmbeddedWorkerInstance> weak_this = weak_factory_.GetWeakPtr(); |
798 callback.Run(status); | 802 callback.Run(status); |
799 if (weak_this && old_status != STOPPED) | 803 if (weak_this && old_status != Status::STOPPED) |
800 FOR_EACH_OBSERVER(Listener, weak_this->listener_list_, | 804 FOR_EACH_OBSERVER(Listener, weak_this->listener_list_, |
801 OnStopped(old_status)); | 805 OnStopped(old_status)); |
802 } | 806 } |
803 | 807 |
804 base::TimeDelta EmbeddedWorkerInstance::UpdateStepTime() { | 808 base::TimeDelta EmbeddedWorkerInstance::UpdateStepTime() { |
805 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 809 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
806 DCHECK(!step_time_.is_null()); | 810 DCHECK(!step_time_.is_null()); |
807 base::TimeTicks now = base::TimeTicks::Now(); | 811 base::TimeTicks now = base::TimeTicks::Now(); |
808 base::TimeDelta duration = now - step_time_; | 812 base::TimeDelta duration = now - step_time_; |
809 step_time_ = now; | 813 step_time_ = now; |
810 return duration; | 814 return duration; |
811 } | 815 } |
812 | 816 |
813 void EmbeddedWorkerInstance::AddMessageToConsole(ConsoleMessageLevel level, | 817 void EmbeddedWorkerInstance::AddMessageToConsole(ConsoleMessageLevel level, |
814 const std::string& message) { | 818 const std::string& message) { |
815 if (status_ != RUNNING && status_ != STARTING) | 819 if (status_ != Status::RUNNING && status_ != Status::STARTING) |
816 return; | 820 return; |
817 registry_->Send(process_id(), new EmbeddedWorkerMsg_AddMessageToConsole( | 821 registry_->Send(process_id(), new EmbeddedWorkerMsg_AddMessageToConsole( |
818 embedded_worker_id_, level, message)); | 822 embedded_worker_id_, level, message)); |
819 } | 823 } |
820 | 824 |
821 // static | 825 // static |
822 std::string EmbeddedWorkerInstance::StatusToString(Status status) { | 826 std::string EmbeddedWorkerInstance::StatusToString(Status status) { |
823 switch (status) { | 827 switch (status) { |
824 case STOPPED: | 828 case Status::STOPPED: |
825 return "STOPPED"; | 829 return "STOPPED"; |
826 case STARTING: | 830 case Status::STARTING: |
827 return "STARTING"; | 831 return "STARTING"; |
828 case RUNNING: | 832 case Status::RUNNING: |
829 return "RUNNING"; | 833 return "RUNNING"; |
830 case STOPPING: | 834 case Status::STOPPING: |
831 return "STOPPING"; | 835 return "STOPPING"; |
832 } | 836 } |
833 NOTREACHED() << status; | 837 NOTREACHED(); |
834 return std::string(); | 838 return std::string(); |
835 } | 839 } |
836 | 840 |
837 // static | 841 // static |
838 std::string EmbeddedWorkerInstance::StartingPhaseToString(StartingPhase phase) { | 842 std::string EmbeddedWorkerInstance::StartingPhaseToString(StartingPhase phase) { |
839 switch (phase) { | 843 switch (phase) { |
840 case NOT_STARTING: | 844 case NOT_STARTING: |
841 return "Not in STARTING status"; | 845 return "Not in STARTING status"; |
842 case ALLOCATING_PROCESS: | 846 case ALLOCATING_PROCESS: |
843 return "Allocating process"; | 847 return "Allocating process"; |
(...skipping 14 matching lines...) Expand all Loading... |
858 case SCRIPT_READ_FINISHED: | 862 case SCRIPT_READ_FINISHED: |
859 return "Script read finished"; | 863 return "Script read finished"; |
860 case STARTING_PHASE_MAX_VALUE: | 864 case STARTING_PHASE_MAX_VALUE: |
861 NOTREACHED(); | 865 NOTREACHED(); |
862 } | 866 } |
863 NOTREACHED() << phase; | 867 NOTREACHED() << phase; |
864 return std::string(); | 868 return std::string(); |
865 } | 869 } |
866 | 870 |
867 } // namespace content | 871 } // namespace content |
OLD | NEW |