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

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

Issue 2039743003: Introduce ServiceWorker.ActivatedWorkerPreparationForMainFrame.Time UMA. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: move GetWorkerPreparationSuffix Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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/service_worker_version.h" 5 #include "content/browser/service_worker/service_worker_version.h"
6 6
7 #include <stddef.h> 7 #include <stddef.h>
8 8
9 #include <limits> 9 #include <limits>
10 #include <map> 10 #include <map>
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after
96 void RunTaskAfterStartWorker( 96 void RunTaskAfterStartWorker(
97 base::WeakPtr<ServiceWorkerVersion> version, 97 base::WeakPtr<ServiceWorkerVersion> version,
98 const StatusCallback& error_callback, 98 const StatusCallback& error_callback,
99 const base::Closure& task, 99 const base::Closure& task,
100 ServiceWorkerStatusCode status) { 100 ServiceWorkerStatusCode status) {
101 if (status != SERVICE_WORKER_OK) { 101 if (status != SERVICE_WORKER_OK) {
102 if (!error_callback.is_null()) 102 if (!error_callback.is_null())
103 error_callback.Run(status); 103 error_callback.Run(status);
104 return; 104 return;
105 } 105 }
106 if (version->running_status() != ServiceWorkerVersion::RUNNING) { 106 if (version->running_status() !=
107 ServiceWorkerVersion::RunningStatus::RUNNING) {
107 // We've tried to start the worker (and it has succeeded), but 108 // We've tried to start the worker (and it has succeeded), but
108 // it looks it's not running yet. 109 // it looks it's not running yet.
109 NOTREACHED() << "The worker's not running after successful StartWorker"; 110 NOTREACHED() << "The worker's not running after successful StartWorker";
110 if (!error_callback.is_null()) 111 if (!error_callback.is_null())
111 error_callback.Run(SERVICE_WORKER_ERROR_START_WORKER_FAILED); 112 error_callback.Run(SERVICE_WORKER_ERROR_START_WORKER_FAILED);
112 return; 113 return;
113 } 114 }
114 task.Run(); 115 task.Run();
115 } 116 }
116 117
(...skipping 202 matching lines...) Expand 10 before | Expand all | Expand 10 after
319 if (!start_callbacks_.empty()) { 320 if (!start_callbacks_.empty()) {
320 // RecordStartWorkerResult must be the first element of start_callbacks_. 321 // RecordStartWorkerResult must be the first element of start_callbacks_.
321 StatusCallback record_start_worker_result = start_callbacks_[0]; 322 StatusCallback record_start_worker_result = start_callbacks_[0];
322 start_callbacks_.clear(); 323 start_callbacks_.clear();
323 record_start_worker_result.Run(SERVICE_WORKER_ERROR_ABORT); 324 record_start_worker_result.Run(SERVICE_WORKER_ERROR_ABORT);
324 } 325 }
325 326
326 if (context_) 327 if (context_)
327 context_->RemoveLiveVersion(version_id_); 328 context_->RemoveLiveVersion(version_id_);
328 329
329 if (running_status() == STARTING || running_status() == RUNNING) 330 if (running_status() == RunningStatus::STARTING ||
331 running_status() == RunningStatus::RUNNING) {
330 embedded_worker_->Stop(); 332 embedded_worker_->Stop();
333 }
331 embedded_worker_->RemoveListener(this); 334 embedded_worker_->RemoveListener(this);
332 } 335 }
333 336
334 void ServiceWorkerVersion::SetStatus(Status status) { 337 void ServiceWorkerVersion::SetStatus(Status status) {
335 if (status_ == status) 338 if (status_ == status)
336 return; 339 return;
337 340
338 TRACE_EVENT2("ServiceWorker", "ServiceWorkerVersion::SetStatus", "Script URL", 341 TRACE_EVENT2("ServiceWorker", "ServiceWorkerVersion::SetStatus", "Script URL",
339 script_url_.spec(), "New Status", VersionStatusToString(status)); 342 script_url_.spec(), "New Status", VersionStatusToString(status));
340 343
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after
439 weak_factory_.GetWeakPtr(), purpose, status_, 442 weak_factory_.GetWeakPtr(), purpose, status_,
440 is_browser_startup_complete, callback)); 443 is_browser_startup_complete, callback));
441 } 444 }
442 445
443 void ServiceWorkerVersion::StopWorker(const StatusCallback& callback) { 446 void ServiceWorkerVersion::StopWorker(const StatusCallback& callback) {
444 TRACE_EVENT_INSTANT2("ServiceWorker", 447 TRACE_EVENT_INSTANT2("ServiceWorker",
445 "ServiceWorkerVersion::StopWorker (instant)", 448 "ServiceWorkerVersion::StopWorker (instant)",
446 TRACE_EVENT_SCOPE_THREAD, "Script", script_url_.spec(), 449 TRACE_EVENT_SCOPE_THREAD, "Script", script_url_.spec(),
447 "Status", VersionStatusToString(status_)); 450 "Status", VersionStatusToString(status_));
448 451
449 if (running_status() == STOPPED) { 452 if (running_status() == RunningStatus::STOPPED) {
450 RunSoon(base::Bind(callback, SERVICE_WORKER_OK)); 453 RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
451 return; 454 return;
452 } 455 }
453 456
454 if (stop_callbacks_.empty()) { 457 if (stop_callbacks_.empty()) {
455 ServiceWorkerStatusCode status = embedded_worker_->Stop(); 458 ServiceWorkerStatusCode status = embedded_worker_->Stop();
456 if (status != SERVICE_WORKER_OK) { 459 if (status != SERVICE_WORKER_OK) {
457 RunSoon(base::Bind(callback, status)); 460 RunSoon(base::Bind(callback, status));
458 return; 461 return;
459 } 462 }
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
502 event_type, error_callback, 505 event_type, error_callback,
503 base::TimeDelta::FromMinutes(kRequestTimeoutMinutes), KILL_ON_TIMEOUT); 506 base::TimeDelta::FromMinutes(kRequestTimeoutMinutes), KILL_ON_TIMEOUT);
504 } 507 }
505 508
506 int ServiceWorkerVersion::StartRequestWithCustomTimeout( 509 int ServiceWorkerVersion::StartRequestWithCustomTimeout(
507 ServiceWorkerMetrics::EventType event_type, 510 ServiceWorkerMetrics::EventType event_type,
508 const StatusCallback& error_callback, 511 const StatusCallback& error_callback,
509 const base::TimeDelta& timeout, 512 const base::TimeDelta& timeout,
510 TimeoutBehavior timeout_behavior) { 513 TimeoutBehavior timeout_behavior) {
511 OnBeginEvent(); 514 OnBeginEvent();
512 DCHECK_EQ(RUNNING, running_status()) 515 DCHECK_EQ(RunningStatus::RUNNING, running_status())
513 << "Can only start a request with a running worker."; 516 << "Can only start a request with a running worker.";
514 DCHECK(event_type == ServiceWorkerMetrics::EventType::INSTALL || 517 DCHECK(event_type == ServiceWorkerMetrics::EventType::INSTALL ||
515 event_type == ServiceWorkerMetrics::EventType::ACTIVATE || 518 event_type == ServiceWorkerMetrics::EventType::ACTIVATE ||
516 event_type == ServiceWorkerMetrics::EventType::MESSAGE || 519 event_type == ServiceWorkerMetrics::EventType::MESSAGE ||
517 status() == ACTIVATED) 520 status() == ACTIVATED)
518 << "Event of type " << static_cast<int>(event_type) 521 << "Event of type " << static_cast<int>(event_type)
519 << " can only be dispatched to an active worker: " << status(); 522 << " can only be dispatched to an active worker: " << status();
520 523
521 PendingRequest<StatusCallback>* request = new PendingRequest<StatusCallback>( 524 PendingRequest<StatusCallback>* request = new PendingRequest<StatusCallback>(
522 error_callback, base::TimeTicks::Now(), event_type); 525 error_callback, base::TimeTicks::Now(), event_type);
(...skipping 26 matching lines...) Expand all
549 // order to release worker resources soon. 552 // order to release worker resources soon.
550 StopWorkerIfIdle(); 553 StopWorkerIfIdle();
551 } 554 }
552 return true; 555 return true;
553 } 556 }
554 557
555 void ServiceWorkerVersion::RunAfterStartWorker( 558 void ServiceWorkerVersion::RunAfterStartWorker(
556 ServiceWorkerMetrics::EventType purpose, 559 ServiceWorkerMetrics::EventType purpose,
557 const base::Closure& task, 560 const base::Closure& task,
558 const StatusCallback& error_callback) { 561 const StatusCallback& error_callback) {
559 if (running_status() == RUNNING) { 562 if (running_status() == RunningStatus::RUNNING) {
560 DCHECK(start_callbacks_.empty()); 563 DCHECK(start_callbacks_.empty());
561 task.Run(); 564 task.Run();
562 return; 565 return;
563 } 566 }
564 StartWorker(purpose, 567 StartWorker(purpose,
565 base::Bind(&RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(), 568 base::Bind(&RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
566 error_callback, task)); 569 error_callback, task));
567 } 570 }
568 571
569 void ServiceWorkerVersion::AddControllee( 572 void ServiceWorkerVersion::AddControllee(
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after
623 } 626 }
624 627
625 void ServiceWorkerVersion::SetStartWorkerStatusCode( 628 void ServiceWorkerVersion::SetStartWorkerStatusCode(
626 ServiceWorkerStatusCode status) { 629 ServiceWorkerStatusCode status) {
627 start_worker_status_ = status; 630 start_worker_status_ = status;
628 } 631 }
629 632
630 void ServiceWorkerVersion::Doom() { 633 void ServiceWorkerVersion::Doom() {
631 DCHECK(!HasControllee()); 634 DCHECK(!HasControllee());
632 SetStatus(REDUNDANT); 635 SetStatus(REDUNDANT);
633 if (running_status() == STARTING || running_status() == RUNNING) { 636 if (running_status() == RunningStatus::STARTING ||
637 running_status() == RunningStatus::RUNNING) {
634 if (embedded_worker()->devtools_attached()) 638 if (embedded_worker()->devtools_attached())
635 stop_when_devtools_detached_ = true; 639 stop_when_devtools_detached_ = true;
636 else 640 else
637 embedded_worker_->Stop(); 641 embedded_worker_->Stop();
638 } 642 }
639 if (!context_) 643 if (!context_)
640 return; 644 return;
641 std::vector<ServiceWorkerDatabase::ResourceRecord> resources; 645 std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
642 script_cache_map_.GetResources(&resources); 646 script_cache_map_.GetResources(&resources);
643 context_->storage()->PurgeResources(resources); 647 context_->storage()->PurgeResources(resources);
644 } 648 }
645 649
646 void ServiceWorkerVersion::SetDevToolsAttached(bool attached) { 650 void ServiceWorkerVersion::SetDevToolsAttached(bool attached) {
647 embedded_worker()->set_devtools_attached(attached); 651 embedded_worker()->set_devtools_attached(attached);
648 if (stop_when_devtools_detached_ && !attached) { 652 if (stop_when_devtools_detached_ && !attached) {
649 DCHECK_EQ(REDUNDANT, status()); 653 DCHECK_EQ(REDUNDANT, status());
650 if (running_status() == STARTING || running_status() == RUNNING) 654 if (running_status() == RunningStatus::STARTING ||
655 running_status() == RunningStatus::RUNNING) {
651 embedded_worker_->Stop(); 656 embedded_worker_->Stop();
657 }
652 return; 658 return;
653 } 659 }
654 if (attached) { 660 if (attached) {
655 // TODO(falken): Canceling the timeouts when debugging could cause 661 // TODO(falken): Canceling the timeouts when debugging could cause
656 // heisenbugs; we should instead run them as normal show an educational 662 // heisenbugs; we should instead run them as normal show an educational
657 // message in DevTools when they occur. crbug.com/470419 663 // message in DevTools when they occur. crbug.com/470419
658 664
659 // Don't record the startup time metric once DevTools is attached. 665 // Don't record the startup time metric once DevTools is attached.
660 ClearTick(&start_time_); 666 ClearTick(&start_time_);
661 skip_recording_startup_time_ = true; 667 skip_recording_startup_time_ = true;
662 668
663 // Cancel request timeouts. 669 // Cancel request timeouts.
664 SetAllRequestExpirations(base::TimeTicks()); 670 SetAllRequestExpirations(base::TimeTicks());
665 return; 671 return;
666 } 672 }
667 if (!start_callbacks_.empty()) { 673 if (!start_callbacks_.empty()) {
668 // Reactivate the timer for start timeout. 674 // Reactivate the timer for start timeout.
669 DCHECK(timeout_timer_.IsRunning()); 675 DCHECK(timeout_timer_.IsRunning());
670 DCHECK(running_status() == STARTING || running_status() == STOPPING) 676 DCHECK(running_status() == RunningStatus::STARTING ||
671 << running_status(); 677 running_status() == RunningStatus::STOPPING)
678 << static_cast<int>(running_status());
672 RestartTick(&start_time_); 679 RestartTick(&start_time_);
673 } 680 }
674 681
675 // Reactivate request timeouts, setting them all to the same expiration time. 682 // Reactivate request timeouts, setting them all to the same expiration time.
676 SetAllRequestExpirations( 683 SetAllRequestExpirations(
677 base::TimeTicks::Now() + 684 base::TimeTicks::Now() +
678 base::TimeDelta::FromMinutes(kRequestTimeoutMinutes)); 685 base::TimeDelta::FromMinutes(kRequestTimeoutMinutes));
679 } 686 }
680 687
681 void ServiceWorkerVersion::SetMainScriptHttpResponseInfo( 688 void ServiceWorkerVersion::SetMainScriptHttpResponseInfo(
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after
733 TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::Request", 740 TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::Request",
734 request, "Error", "Service Disconnected"); 741 request, "Error", "Service Disconnected");
735 request->callback.Run(SERVICE_WORKER_ERROR_FAILED); 742 request->callback.Run(SERVICE_WORKER_ERROR_FAILED);
736 worker_->custom_requests_.Remove(iter.GetCurrentKey()); 743 worker_->custom_requests_.Remove(iter.GetCurrentKey());
737 } 744 }
738 iter.Advance(); 745 iter.Advance();
739 } 746 }
740 } 747 }
741 748
742 void ServiceWorkerVersion::OnThreadStarted() { 749 void ServiceWorkerVersion::OnThreadStarted() {
743 DCHECK_EQ(STARTING, running_status()); 750 DCHECK_EQ(RunningStatus::STARTING, running_status());
744 // Activate ping/pong now that JavaScript execution will start. 751 // Activate ping/pong now that JavaScript execution will start.
745 ping_controller_->Activate(); 752 ping_controller_->Activate();
746 } 753 }
747 754
748 void ServiceWorkerVersion::OnStarting() { 755 void ServiceWorkerVersion::OnStarting() {
749 FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this)); 756 FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this));
750 } 757 }
751 758
752 void ServiceWorkerVersion::OnStarted() { 759 void ServiceWorkerVersion::OnStarted() {
753 DCHECK_EQ(RUNNING, running_status()); 760 DCHECK_EQ(RunningStatus::RUNNING, running_status());
754 RestartTick(&idle_time_); 761 RestartTick(&idle_time_);
755 762
756 // Fire all start callbacks. 763 // Fire all start callbacks.
757 scoped_refptr<ServiceWorkerVersion> protect(this); 764 scoped_refptr<ServiceWorkerVersion> protect(this);
758 RunCallbacks(this, &start_callbacks_, SERVICE_WORKER_OK); 765 RunCallbacks(this, &start_callbacks_, SERVICE_WORKER_OK);
759 FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this)); 766 FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this));
760 } 767 }
761 768
762 void ServiceWorkerVersion::OnStopping() { 769 void ServiceWorkerVersion::OnStopping() {
763 DCHECK(stop_time_.is_null()); 770 DCHECK(stop_time_.is_null());
(...skipping 128 matching lines...) Expand 10 before | Expand all | Expand 10 after
892 899
893 void ServiceWorkerVersion::OnGetClientFinished( 900 void ServiceWorkerVersion::OnGetClientFinished(
894 int request_id, 901 int request_id,
895 const ServiceWorkerClientInfo& client_info) { 902 const ServiceWorkerClientInfo& client_info) {
896 DCHECK_CURRENTLY_ON(BrowserThread::IO); 903 DCHECK_CURRENTLY_ON(BrowserThread::IO);
897 TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::OnGetClient", 904 TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::OnGetClient",
898 request_id, "client_type", client_info.client_type); 905 request_id, "client_type", client_info.client_type);
899 906
900 // When Clients.get() is called on the script evaluation phase, the running 907 // When Clients.get() is called on the script evaluation phase, the running
901 // status can be STARTING here. 908 // status can be STARTING here.
902 if (running_status() != STARTING && running_status() != RUNNING) 909 if (running_status() != RunningStatus::STARTING &&
910 running_status() != RunningStatus::RUNNING) {
903 return; 911 return;
912 }
904 913
905 embedded_worker_->SendMessage( 914 embedded_worker_->SendMessage(
906 ServiceWorkerMsg_DidGetClient(request_id, client_info)); 915 ServiceWorkerMsg_DidGetClient(request_id, client_info));
907 } 916 }
908 917
909 void ServiceWorkerVersion::OnGetClients( 918 void ServiceWorkerVersion::OnGetClients(
910 int request_id, 919 int request_id,
911 const ServiceWorkerClientQueryOptions& options) { 920 const ServiceWorkerClientQueryOptions& options) {
912 TRACE_EVENT_ASYNC_BEGIN2( 921 TRACE_EVENT_ASYNC_BEGIN2(
913 "ServiceWorker", "ServiceWorkerVersion::OnGetClients", request_id, 922 "ServiceWorker", "ServiceWorkerVersion::OnGetClients", request_id,
914 "client_type", options.client_type, "include_uncontrolled", 923 "client_type", options.client_type, "include_uncontrolled",
915 options.include_uncontrolled); 924 options.include_uncontrolled);
916 service_worker_client_utils::GetClients( 925 service_worker_client_utils::GetClients(
917 weak_factory_.GetWeakPtr(), options, 926 weak_factory_.GetWeakPtr(), options,
918 base::Bind(&ServiceWorkerVersion::OnGetClientsFinished, 927 base::Bind(&ServiceWorkerVersion::OnGetClientsFinished,
919 weak_factory_.GetWeakPtr(), request_id)); 928 weak_factory_.GetWeakPtr(), request_id));
920 } 929 }
921 930
922 void ServiceWorkerVersion::OnGetClientsFinished(int request_id, 931 void ServiceWorkerVersion::OnGetClientsFinished(int request_id,
923 ServiceWorkerClients* clients) { 932 ServiceWorkerClients* clients) {
924 DCHECK_CURRENTLY_ON(BrowserThread::IO); 933 DCHECK_CURRENTLY_ON(BrowserThread::IO);
925 TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::OnGetClients", 934 TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::OnGetClients",
926 request_id, "The number of clients", clients->size()); 935 request_id, "The number of clients", clients->size());
927 936
928 // When Clients.matchAll() is called on the script evaluation phase, the 937 // When Clients.matchAll() is called on the script evaluation phase, the
929 // running status can be STARTING here. 938 // running status can be STARTING here.
930 if (running_status() != STARTING && running_status() != RUNNING) 939 if (running_status() != RunningStatus::STARTING &&
940 running_status() != RunningStatus::RUNNING) {
931 return; 941 return;
942 }
932 943
933 embedded_worker_->SendMessage( 944 embedded_worker_->SendMessage(
934 ServiceWorkerMsg_DidGetClients(request_id, *clients)); 945 ServiceWorkerMsg_DidGetClients(request_id, *clients));
935 } 946 }
936 947
937 void ServiceWorkerVersion::OnSimpleEventResponse( 948 void ServiceWorkerVersion::OnSimpleEventResponse(
938 int request_id, 949 int request_id,
939 blink::WebServiceWorkerEventResult result) { 950 blink::WebServiceWorkerEventResult result) {
940 // Copy error callback before calling FinishRequest. 951 // Copy error callback before calling FinishRequest.
941 PendingRequest<StatusCallback>* request = custom_requests_.Lookup(request_id); 952 PendingRequest<StatusCallback>* request = custom_requests_.Lookup(request_id);
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
986 base::Bind(&ServiceWorkerVersion::OnOpenWindowFinished, 997 base::Bind(&ServiceWorkerVersion::OnOpenWindowFinished,
987 weak_factory_.GetWeakPtr(), request_id)); 998 weak_factory_.GetWeakPtr(), request_id));
988 } 999 }
989 1000
990 void ServiceWorkerVersion::OnOpenWindowFinished( 1001 void ServiceWorkerVersion::OnOpenWindowFinished(
991 int request_id, 1002 int request_id,
992 ServiceWorkerStatusCode status, 1003 ServiceWorkerStatusCode status,
993 const ServiceWorkerClientInfo& client_info) { 1004 const ServiceWorkerClientInfo& client_info) {
994 DCHECK_CURRENTLY_ON(BrowserThread::IO); 1005 DCHECK_CURRENTLY_ON(BrowserThread::IO);
995 1006
996 if (running_status() != RUNNING) 1007 if (running_status() != RunningStatus::RUNNING)
997 return; 1008 return;
998 1009
999 if (status != SERVICE_WORKER_OK) { 1010 if (status != SERVICE_WORKER_OK) {
1000 embedded_worker_->SendMessage(ServiceWorkerMsg_OpenWindowError( 1011 embedded_worker_->SendMessage(ServiceWorkerMsg_OpenWindowError(
1001 request_id, "Something went wrong while trying to open the window.")); 1012 request_id, "Something went wrong while trying to open the window."));
1002 return; 1013 return;
1003 } 1014 }
1004 1015
1005 embedded_worker_->SendMessage( 1016 embedded_worker_->SendMessage(
1006 ServiceWorkerMsg_OpenWindowResponse(request_id, client_info)); 1017 ServiceWorkerMsg_OpenWindowResponse(request_id, client_info));
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after
1094 service_worker_client_utils::FocusWindowClient( 1105 service_worker_client_utils::FocusWindowClient(
1095 provider_host, base::Bind(&ServiceWorkerVersion::OnFocusClientFinished, 1106 provider_host, base::Bind(&ServiceWorkerVersion::OnFocusClientFinished,
1096 weak_factory_.GetWeakPtr(), request_id)); 1107 weak_factory_.GetWeakPtr(), request_id));
1097 } 1108 }
1098 1109
1099 void ServiceWorkerVersion::OnFocusClientFinished( 1110 void ServiceWorkerVersion::OnFocusClientFinished(
1100 int request_id, 1111 int request_id,
1101 const ServiceWorkerClientInfo& client_info) { 1112 const ServiceWorkerClientInfo& client_info) {
1102 DCHECK_CURRENTLY_ON(BrowserThread::IO); 1113 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1103 1114
1104 if (running_status() != RUNNING) 1115 if (running_status() != RunningStatus::RUNNING)
1105 return; 1116 return;
1106 1117
1107 embedded_worker_->SendMessage( 1118 embedded_worker_->SendMessage(
1108 ServiceWorkerMsg_FocusClientResponse(request_id, client_info)); 1119 ServiceWorkerMsg_FocusClientResponse(request_id, client_info));
1109 } 1120 }
1110 1121
1111 void ServiceWorkerVersion::OnNavigateClient(int request_id, 1122 void ServiceWorkerVersion::OnNavigateClient(int request_id,
1112 const std::string& client_uuid, 1123 const std::string& client_uuid,
1113 const GURL& url) { 1124 const GURL& url) {
1114 if (!context_) 1125 if (!context_)
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
1150 context_, base::Bind(&ServiceWorkerVersion::OnNavigateClientFinished, 1161 context_, base::Bind(&ServiceWorkerVersion::OnNavigateClientFinished,
1151 weak_factory_.GetWeakPtr(), request_id)); 1162 weak_factory_.GetWeakPtr(), request_id));
1152 } 1163 }
1153 1164
1154 void ServiceWorkerVersion::OnNavigateClientFinished( 1165 void ServiceWorkerVersion::OnNavigateClientFinished(
1155 int request_id, 1166 int request_id,
1156 ServiceWorkerStatusCode status, 1167 ServiceWorkerStatusCode status,
1157 const ServiceWorkerClientInfo& client_info) { 1168 const ServiceWorkerClientInfo& client_info) {
1158 DCHECK_CURRENTLY_ON(BrowserThread::IO); 1169 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1159 1170
1160 if (running_status() != RUNNING) 1171 if (running_status() != RunningStatus::RUNNING)
1161 return; 1172 return;
1162 1173
1163 if (status != SERVICE_WORKER_OK) { 1174 if (status != SERVICE_WORKER_OK) {
1164 embedded_worker_->SendMessage( 1175 embedded_worker_->SendMessage(
1165 ServiceWorkerMsg_NavigateClientError(request_id, GURL())); 1176 ServiceWorkerMsg_NavigateClientError(request_id, GURL()));
1166 return; 1177 return;
1167 } 1178 }
1168 1179
1169 embedded_worker_->SendMessage( 1180 embedded_worker_->SendMessage(
1170 ServiceWorkerMsg_NavigateClientResponse(request_id, client_info)); 1181 ServiceWorkerMsg_NavigateClientResponse(request_id, client_info));
1171 } 1182 }
1172 1183
1173 void ServiceWorkerVersion::OnSkipWaiting(int request_id) { 1184 void ServiceWorkerVersion::OnSkipWaiting(int request_id) {
1174 skip_waiting_ = true; 1185 skip_waiting_ = true;
1175 if (status_ != INSTALLED) 1186 if (status_ != INSTALLED)
1176 return DidSkipWaiting(request_id); 1187 return DidSkipWaiting(request_id);
1177 1188
1178 if (!context_) 1189 if (!context_)
1179 return; 1190 return;
1180 ServiceWorkerRegistration* registration = 1191 ServiceWorkerRegistration* registration =
1181 context_->GetLiveRegistration(registration_id_); 1192 context_->GetLiveRegistration(registration_id_);
1182 if (!registration) 1193 if (!registration)
1183 return; 1194 return;
1184 pending_skip_waiting_requests_.push_back(request_id); 1195 pending_skip_waiting_requests_.push_back(request_id);
1185 if (pending_skip_waiting_requests_.size() == 1) 1196 if (pending_skip_waiting_requests_.size() == 1)
1186 registration->ActivateWaitingVersionWhenReady(); 1197 registration->ActivateWaitingVersionWhenReady();
1187 } 1198 }
1188 1199
1189 void ServiceWorkerVersion::DidSkipWaiting(int request_id) { 1200 void ServiceWorkerVersion::DidSkipWaiting(int request_id) {
1190 if (running_status() == STARTING || running_status() == RUNNING) 1201 if (running_status() == RunningStatus::STARTING ||
1202 running_status() == RunningStatus::RUNNING) {
1191 embedded_worker_->SendMessage(ServiceWorkerMsg_DidSkipWaiting(request_id)); 1203 embedded_worker_->SendMessage(ServiceWorkerMsg_DidSkipWaiting(request_id));
1204 }
1192 } 1205 }
1193 1206
1194 void ServiceWorkerVersion::OnClaimClients(int request_id) { 1207 void ServiceWorkerVersion::OnClaimClients(int request_id) {
1195 if (status_ != ACTIVATING && status_ != ACTIVATED) { 1208 if (status_ != ACTIVATING && status_ != ACTIVATED) {
1196 embedded_worker_->SendMessage(ServiceWorkerMsg_ClaimClientsError( 1209 embedded_worker_->SendMessage(ServiceWorkerMsg_ClaimClientsError(
1197 request_id, blink::WebServiceWorkerError::ErrorTypeState, 1210 request_id, blink::WebServiceWorkerError::ErrorTypeState,
1198 base::ASCIIToUTF16(kClaimClientsStateErrorMesage))); 1211 base::ASCIIToUTF16(kClaimClientsStateErrorMesage)));
1199 return; 1212 return;
1200 } 1213 }
1201 if (context_) { 1214 if (context_) {
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after
1280 RecordStartWorkerResult(purpose, prestart_status, kInvalidTraceId, 1293 RecordStartWorkerResult(purpose, prestart_status, kInvalidTraceId,
1281 is_browser_startup_complete, 1294 is_browser_startup_complete,
1282 SERVICE_WORKER_ERROR_REDUNDANT); 1295 SERVICE_WORKER_ERROR_REDUNDANT);
1283 RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_REDUNDANT)); 1296 RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_REDUNDANT));
1284 return; 1297 return;
1285 } 1298 }
1286 1299
1287 MarkIfStale(); 1300 MarkIfStale();
1288 1301
1289 switch (running_status()) { 1302 switch (running_status()) {
1290 case RUNNING: 1303 case RunningStatus::RUNNING:
1291 RunSoon(base::Bind(callback, SERVICE_WORKER_OK)); 1304 RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
1292 return; 1305 return;
1293 case STARTING: 1306 case RunningStatus::STARTING:
1294 DCHECK(!start_callbacks_.empty()); 1307 DCHECK(!start_callbacks_.empty());
1295 break; 1308 break;
1296 case STOPPING: 1309 case RunningStatus::STOPPING:
1297 case STOPPED: 1310 case RunningStatus::STOPPED:
1298 if (start_callbacks_.empty()) { 1311 if (start_callbacks_.empty()) {
1299 int trace_id = NextTraceId(); 1312 int trace_id = NextTraceId();
1300 TRACE_EVENT_ASYNC_BEGIN2( 1313 TRACE_EVENT_ASYNC_BEGIN2(
1301 "ServiceWorker", "ServiceWorkerVersion::StartWorker", trace_id, 1314 "ServiceWorker", "ServiceWorkerVersion::StartWorker", trace_id,
1302 "Script", script_url_.spec(), "Purpose", 1315 "Script", script_url_.spec(), "Purpose",
1303 ServiceWorkerMetrics::EventTypeToString(purpose)); 1316 ServiceWorkerMetrics::EventTypeToString(purpose));
1304 start_callbacks_.push_back( 1317 start_callbacks_.push_back(
1305 base::Bind(&ServiceWorkerVersion::RecordStartWorkerResult, 1318 base::Bind(&ServiceWorkerVersion::RecordStartWorkerResult,
1306 weak_factory_.GetWeakPtr(), purpose, prestart_status, 1319 weak_factory_.GetWeakPtr(), purpose, prestart_status,
1307 trace_id, is_browser_startup_complete)); 1320 trace_id, is_browser_startup_complete));
1308 } 1321 }
1309 break; 1322 break;
1310 } 1323 }
1311 1324
1312 // Keep the live registration while starting the worker. 1325 // Keep the live registration while starting the worker.
1313 start_callbacks_.push_back( 1326 start_callbacks_.push_back(
1314 base::Bind(&RunStartWorkerCallback, callback, protect)); 1327 base::Bind(&RunStartWorkerCallback, callback, protect));
1315 1328
1316 if (running_status() == STOPPED) 1329 if (running_status() == RunningStatus::STOPPED)
1317 StartWorkerInternal(); 1330 StartWorkerInternal();
1318 DCHECK(timeout_timer_.IsRunning()); 1331 DCHECK(timeout_timer_.IsRunning());
1319 } 1332 }
1320 1333
1321 void ServiceWorkerVersion::StartWorkerInternal() { 1334 void ServiceWorkerVersion::StartWorkerInternal() {
1322 DCHECK_EQ(STOPPED, running_status()); 1335 DCHECK_EQ(RunningStatus::STOPPED, running_status());
1323 1336
1324 DCHECK(!metrics_); 1337 DCHECK(!metrics_);
1325 metrics_.reset(new Metrics(this)); 1338 metrics_.reset(new Metrics(this));
1326 1339
1327 StartTimeoutTimer(); 1340 StartTimeoutTimer();
1328 1341
1329 std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params( 1342 std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params(
1330 new EmbeddedWorkerMsg_StartWorker_Params()); 1343 new EmbeddedWorkerMsg_StartWorker_Params());
1331 params->service_worker_version_id = version_id_; 1344 params->service_worker_version_id = version_id_;
1332 params->scope = scope_; 1345 params->scope = scope_;
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
1378 void ServiceWorkerVersion::SetTimeoutTimerInterval(base::TimeDelta interval) { 1391 void ServiceWorkerVersion::SetTimeoutTimerInterval(base::TimeDelta interval) {
1379 DCHECK(timeout_timer_.IsRunning()); 1392 DCHECK(timeout_timer_.IsRunning());
1380 if (timeout_timer_.GetCurrentDelay() != interval) { 1393 if (timeout_timer_.GetCurrentDelay() != interval) {
1381 timeout_timer_.Stop(); 1394 timeout_timer_.Stop();
1382 timeout_timer_.Start(FROM_HERE, interval, this, 1395 timeout_timer_.Start(FROM_HERE, interval, this,
1383 &ServiceWorkerVersion::OnTimeoutTimer); 1396 &ServiceWorkerVersion::OnTimeoutTimer);
1384 } 1397 }
1385 } 1398 }
1386 1399
1387 void ServiceWorkerVersion::OnTimeoutTimer() { 1400 void ServiceWorkerVersion::OnTimeoutTimer() {
1388 DCHECK(running_status() == STARTING || running_status() == RUNNING || 1401 DCHECK(running_status() == RunningStatus::STARTING ||
1389 running_status() == STOPPING) 1402 running_status() == RunningStatus::RUNNING ||
1390 << running_status(); 1403 running_status() == RunningStatus::STOPPING)
1404 << static_cast<int>(running_status());
1391 1405
1392 if (!context_) 1406 if (!context_)
1393 return; 1407 return;
1394 1408
1395 MarkIfStale(); 1409 MarkIfStale();
1396 1410
1397 // Stopping the worker hasn't finished within a certain period. 1411 // Stopping the worker hasn't finished within a certain period.
1398 if (GetTickDuration(stop_time_) > 1412 if (GetTickDuration(stop_time_) >
1399 base::TimeDelta::FromSeconds(kStopWorkerTimeoutSeconds)) { 1413 base::TimeDelta::FromSeconds(kStopWorkerTimeoutSeconds)) {
1400 DCHECK_EQ(STOPPING, running_status()); 1414 DCHECK_EQ(RunningStatus::STOPPING, running_status());
1401 if (IsInstalled(status())) { 1415 if (IsInstalled(status())) {
1402 ServiceWorkerMetrics::RecordWorkerStopped( 1416 ServiceWorkerMetrics::RecordWorkerStopped(
1403 ServiceWorkerMetrics::StopStatus::TIMEOUT); 1417 ServiceWorkerMetrics::StopStatus::TIMEOUT);
1404 } 1418 }
1405 ReportError(SERVICE_WORKER_ERROR_TIMEOUT, "DETACH_STALLED_IN_STOPPING"); 1419 ReportError(SERVICE_WORKER_ERROR_TIMEOUT, "DETACH_STALLED_IN_STOPPING");
1406 1420
1407 // Detach the worker. Remove |this| as a listener first; otherwise 1421 // Detach the worker. Remove |this| as a listener first; otherwise
1408 // OnStoppedInternal might try to restart before the new worker 1422 // OnStoppedInternal might try to restart before the new worker
1409 // is created. 1423 // is created.
1410 embedded_worker_->RemoveListener(this); 1424 embedded_worker_->RemoveListener(this);
1411 embedded_worker_->Detach(); 1425 embedded_worker_->Detach();
1412 embedded_worker_ = context_->embedded_worker_registry()->CreateWorker(); 1426 embedded_worker_ = context_->embedded_worker_registry()->CreateWorker();
1413 embedded_worker_->AddListener(this); 1427 embedded_worker_->AddListener(this);
1414 1428
1415 // Call OnStoppedInternal to fail callbacks and possibly restart. 1429 // Call OnStoppedInternal to fail callbacks and possibly restart.
1416 OnStoppedInternal(EmbeddedWorkerInstance::STOPPING); 1430 OnStoppedInternal(EmbeddedWorkerInstance::Status::STOPPING);
1417 return; 1431 return;
1418 } 1432 }
1419 1433
1420 // Trigger update if worker is stale and we waited long enough for it to go 1434 // Trigger update if worker is stale and we waited long enough for it to go
1421 // idle. 1435 // idle.
1422 if (GetTickDuration(stale_time_) > 1436 if (GetTickDuration(stale_time_) >
1423 base::TimeDelta::FromMinutes(kRequestTimeoutMinutes)) { 1437 base::TimeDelta::FromMinutes(kRequestTimeoutMinutes)) {
1424 ClearTick(&stale_time_); 1438 ClearTick(&stale_time_);
1425 if (!update_timer_.IsRunning()) 1439 if (!update_timer_.IsRunning())
1426 ScheduleUpdate(); 1440 ScheduleUpdate();
1427 } 1441 }
1428 1442
1429 // Starting a worker hasn't finished within a certain period. 1443 // Starting a worker hasn't finished within a certain period.
1430 const base::TimeDelta start_limit = 1444 const base::TimeDelta start_limit =
1431 IsInstalled(status()) 1445 IsInstalled(status())
1432 ? base::TimeDelta::FromSeconds(kStartInstalledWorkerTimeoutSeconds) 1446 ? base::TimeDelta::FromSeconds(kStartInstalledWorkerTimeoutSeconds)
1433 : base::TimeDelta::FromMinutes(kStartNewWorkerTimeoutMinutes); 1447 : base::TimeDelta::FromMinutes(kStartNewWorkerTimeoutMinutes);
1434 if (GetTickDuration(start_time_) > start_limit) { 1448 if (GetTickDuration(start_time_) > start_limit) {
1435 DCHECK(running_status() == STARTING || running_status() == STOPPING) 1449 DCHECK(running_status() == RunningStatus::STARTING ||
1436 << running_status(); 1450 running_status() == RunningStatus::STOPPING)
1451 << static_cast<int>(running_status());
1437 scoped_refptr<ServiceWorkerVersion> protect(this); 1452 scoped_refptr<ServiceWorkerVersion> protect(this);
1438 RunCallbacks(this, &start_callbacks_, SERVICE_WORKER_ERROR_TIMEOUT); 1453 RunCallbacks(this, &start_callbacks_, SERVICE_WORKER_ERROR_TIMEOUT);
1439 if (running_status() == STARTING) 1454 if (running_status() == RunningStatus::STARTING)
1440 embedded_worker_->Stop(); 1455 embedded_worker_->Stop();
1441 return; 1456 return;
1442 } 1457 }
1443 1458
1444 // Requests have not finished before their expiration. 1459 // Requests have not finished before their expiration.
1445 bool stop_for_timeout = false; 1460 bool stop_for_timeout = false;
1446 while (!requests_.empty()) { 1461 while (!requests_.empty()) {
1447 RequestInfo info = requests_.top(); 1462 RequestInfo info = requests_.top();
1448 if (!RequestExpired(info.expiration)) 1463 if (!RequestExpired(info.expiration))
1449 break; 1464 break;
1450 if (MaybeTimeOutRequest(info)) { 1465 if (MaybeTimeOutRequest(info)) {
1451 stop_for_timeout = 1466 stop_for_timeout =
1452 stop_for_timeout || info.timeout_behavior == KILL_ON_TIMEOUT; 1467 stop_for_timeout || info.timeout_behavior == KILL_ON_TIMEOUT;
1453 ServiceWorkerMetrics::RecordEventTimeout(info.event_type); 1468 ServiceWorkerMetrics::RecordEventTimeout(info.event_type);
1454 } 1469 }
1455 requests_.pop(); 1470 requests_.pop();
1456 } 1471 }
1457 if (stop_for_timeout && running_status() != STOPPING) 1472 if (stop_for_timeout && running_status() != RunningStatus::STOPPING)
1458 embedded_worker_->Stop(); 1473 embedded_worker_->Stop();
1459 1474
1460 // For the timeouts below, there are no callbacks to timeout so there is 1475 // For the timeouts below, there are no callbacks to timeout so there is
1461 // nothing more to do if the worker is already stopping. 1476 // nothing more to do if the worker is already stopping.
1462 if (running_status() == STOPPING) 1477 if (running_status() == RunningStatus::STOPPING)
1463 return; 1478 return;
1464 1479
1465 // The worker has been idle for longer than a certain period. 1480 // The worker has been idle for longer than a certain period.
1466 if (GetTickDuration(idle_time_) > 1481 if (GetTickDuration(idle_time_) >
1467 base::TimeDelta::FromSeconds(kIdleWorkerTimeoutSeconds)) { 1482 base::TimeDelta::FromSeconds(kIdleWorkerTimeoutSeconds)) {
1468 StopWorkerIfIdle(); 1483 StopWorkerIfIdle();
1469 return; 1484 return;
1470 } 1485 }
1471 1486
1472 // Check ping status. 1487 // Check ping status.
1473 ping_controller_->CheckPingStatus(); 1488 ping_controller_->CheckPingStatus();
1474 } 1489 }
1475 1490
1476 ServiceWorkerStatusCode ServiceWorkerVersion::PingWorker() { 1491 ServiceWorkerStatusCode ServiceWorkerVersion::PingWorker() {
1477 DCHECK(running_status() == STARTING || running_status() == RUNNING); 1492 DCHECK(running_status() == RunningStatus::STARTING ||
1493 running_status() == RunningStatus::RUNNING);
1478 return embedded_worker_->SendMessage(ServiceWorkerMsg_Ping()); 1494 return embedded_worker_->SendMessage(ServiceWorkerMsg_Ping());
1479 } 1495 }
1480 1496
1481 void ServiceWorkerVersion::OnPingTimeout() { 1497 void ServiceWorkerVersion::OnPingTimeout() {
1482 DCHECK(running_status() == STARTING || running_status() == RUNNING); 1498 DCHECK(running_status() == RunningStatus::STARTING ||
1499 running_status() == RunningStatus::RUNNING);
1483 // TODO(falken): Show a message to the developer that the SW was stopped due 1500 // TODO(falken): Show a message to the developer that the SW was stopped due
1484 // to timeout (crbug.com/457968). Also, change the error code to 1501 // to timeout (crbug.com/457968). Also, change the error code to
1485 // SERVICE_WORKER_ERROR_TIMEOUT. 1502 // SERVICE_WORKER_ERROR_TIMEOUT.
1486 StopWorkerIfIdle(); 1503 StopWorkerIfIdle();
1487 } 1504 }
1488 1505
1489 void ServiceWorkerVersion::StopWorkerIfIdle() { 1506 void ServiceWorkerVersion::StopWorkerIfIdle() {
1490 if (HasInflightRequests() && !ping_controller_->IsTimedOut()) 1507 if (HasInflightRequests() && !ping_controller_->IsTimedOut())
1491 return; 1508 return;
1492 if (running_status() == STOPPED || running_status() == STOPPING || 1509 if (running_status() == RunningStatus::STOPPED ||
1493 !stop_callbacks_.empty()) { 1510 running_status() == RunningStatus::STOPPING || !stop_callbacks_.empty()) {
1494 return; 1511 return;
1495 } 1512 }
1496 1513
1497 embedded_worker_->StopIfIdle(); 1514 embedded_worker_->StopIfIdle();
1498 } 1515 }
1499 1516
1500 bool ServiceWorkerVersion::HasInflightRequests() const { 1517 bool ServiceWorkerVersion::HasInflightRequests() const {
1501 return !custom_requests_.IsEmpty() || !streaming_url_request_jobs_.empty(); 1518 return !custom_requests_.IsEmpty() || !streaming_url_request_jobs_.empty();
1502 } 1519 }
1503 1520
(...skipping 27 matching lines...) Expand all
1531 } 1548 }
1532 1549
1533 if (status != SERVICE_WORKER_ERROR_TIMEOUT) 1550 if (status != SERVICE_WORKER_ERROR_TIMEOUT)
1534 return; 1551 return;
1535 EmbeddedWorkerInstance::StartingPhase phase = 1552 EmbeddedWorkerInstance::StartingPhase phase =
1536 EmbeddedWorkerInstance::NOT_STARTING; 1553 EmbeddedWorkerInstance::NOT_STARTING;
1537 EmbeddedWorkerInstance::Status running_status = embedded_worker_->status(); 1554 EmbeddedWorkerInstance::Status running_status = embedded_worker_->status();
1538 // Build an artifical JavaScript exception to show in the ServiceWorker 1555 // Build an artifical JavaScript exception to show in the ServiceWorker
1539 // log for developers; it's not user-facing so it's not a localized resource. 1556 // log for developers; it's not user-facing so it's not a localized resource.
1540 std::string message = "ServiceWorker startup timed out. "; 1557 std::string message = "ServiceWorker startup timed out. ";
1541 if (running_status != EmbeddedWorkerInstance::STARTING) { 1558 if (running_status != EmbeddedWorkerInstance::Status::STARTING) {
1542 message.append("The worker had unexpected status: "); 1559 message.append("The worker had unexpected status: ");
1543 message.append(EmbeddedWorkerInstance::StatusToString(running_status)); 1560 message.append(EmbeddedWorkerInstance::StatusToString(running_status));
1544 } else { 1561 } else {
1545 phase = embedded_worker_->starting_phase(); 1562 phase = embedded_worker_->starting_phase();
1546 message.append("The worker was in startup phase: "); 1563 message.append("The worker was in startup phase: ");
1547 message.append(EmbeddedWorkerInstance::StartingPhaseToString(phase)); 1564 message.append(EmbeddedWorkerInstance::StartingPhaseToString(phase));
1548 } 1565 }
1549 message.append("."); 1566 message.append(".");
1550 OnReportException(base::UTF8ToUTF16(message), -1, -1, GURL()); 1567 OnReportException(base::UTF8ToUTF16(message), -1, -1, GURL());
1551 DVLOG(1) << message; 1568 DVLOG(1) << message;
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after
1632 } 1649 }
1633 1650
1634 if (status != SERVICE_WORKER_OK || registration->active_version() != this) 1651 if (status != SERVICE_WORKER_OK || registration->active_version() != this)
1635 return; 1652 return;
1636 context_->UpdateServiceWorker(registration.get(), 1653 context_->UpdateServiceWorker(registration.get(),
1637 false /* force_bypass_cache */); 1654 false /* force_bypass_cache */);
1638 } 1655 }
1639 1656
1640 void ServiceWorkerVersion::OnStoppedInternal( 1657 void ServiceWorkerVersion::OnStoppedInternal(
1641 EmbeddedWorkerInstance::Status old_status) { 1658 EmbeddedWorkerInstance::Status old_status) {
1642 DCHECK_EQ(STOPPED, running_status()); 1659 DCHECK_EQ(RunningStatus::STOPPED, running_status());
1643 scoped_refptr<ServiceWorkerVersion> protect; 1660 scoped_refptr<ServiceWorkerVersion> protect;
1644 if (!in_dtor_) 1661 if (!in_dtor_)
1645 protect = this; 1662 protect = this;
1646 1663
1647 DCHECK(metrics_); 1664 DCHECK(metrics_);
1648 metrics_.reset(); 1665 metrics_.reset();
1649 1666
1650 bool should_restart = !is_redundant() && !start_callbacks_.empty() && 1667 bool should_restart =
1651 (old_status != EmbeddedWorkerInstance::STARTING) && 1668 !is_redundant() && !start_callbacks_.empty() &&
1652 !in_dtor_ && !ping_controller_->IsTimedOut(); 1669 (old_status != EmbeddedWorkerInstance::Status::STARTING) && !in_dtor_ &&
1670 !ping_controller_->IsTimedOut();
1653 1671
1654 if (!stop_time_.is_null()) { 1672 if (!stop_time_.is_null()) {
1655 TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::StopWorker", 1673 TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::StopWorker",
1656 stop_time_.ToInternalValue(), "Restart", 1674 stop_time_.ToInternalValue(), "Restart",
1657 should_restart); 1675 should_restart);
1658 ClearTick(&stop_time_); 1676 ClearTick(&stop_time_);
1659 } 1677 }
1660 StopTimeoutTimer(); 1678 StopTimeoutTimer();
1661 1679
1662 // Fire all stop callbacks. 1680 // Fire all stop callbacks.
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
1695 StartWorkerInternal(); 1713 StartWorkerInternal();
1696 } 1714 }
1697 1715
1698 void ServiceWorkerVersion::OnMojoConnectionError(const char* service_name) { 1716 void ServiceWorkerVersion::OnMojoConnectionError(const char* service_name) {
1699 // Simply deleting the service will cause error callbacks to be called from 1717 // Simply deleting the service will cause error callbacks to be called from
1700 // the destructor of the MojoServiceWrapper instance. 1718 // the destructor of the MojoServiceWrapper instance.
1701 mojo_services_.erase(service_name); 1719 mojo_services_.erase(service_name);
1702 } 1720 }
1703 1721
1704 void ServiceWorkerVersion::OnBeginEvent() { 1722 void ServiceWorkerVersion::OnBeginEvent() {
1705 if (should_exclude_from_uma_ || running_status() != RUNNING || 1723 if (should_exclude_from_uma_ || running_status() != RunningStatus::RUNNING ||
1706 idle_time_.is_null()) { 1724 idle_time_.is_null()) {
1707 return; 1725 return;
1708 } 1726 }
1709 ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() - 1727 ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
1710 idle_time_); 1728 idle_time_);
1711 } 1729 }
1712 1730
1713 } // namespace content 1731 } // namespace content
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698